/*
 Copyright(c) 2011 Sencha Inc.
 licensing@sencha.com
 http://www.sencha.com/touchlicense
 */
var Ext={}
if (typeof Ext === "undefined") {
    Ext = {}
}
Ext.apply = (function () {
    for (var a in {valueOf:1}) {
        return function (c, b, e) {
            if (e) {
                Ext.apply(c, e)
            }
            if (c && b && typeof b === "object") {
                for (var d in b) {
                    c[d] = b[d]
                }
            }
            return c
        }
    }
    return function (c, b, e) {
        if (e) {
            Ext.apply(c, e)
        }
        if (c && b && typeof b === "object") {
            for (var d in b) {
                c[d] = b[d]
            }
            if (b.toString !== Object.prototype.toString) {
                c.toString = b.toString
            }
            if (b.valueOf !== Object.prototype.valueOf) {
                c.valueOf = b.valueOf
            }
        }
        return c
    }
})();
Ext.apply(Ext, {platformVersion:"1.0", platformVersionDetail:{major:1, minor:0, patch:3}, userAgent:navigator.userAgent.toLowerCase(), cache:{}, idSeed:1000, BLANK_IMAGE_URL:"", isStrict:document.compatMode == "CSS1Compat", windowId:"ext-window", documentId:"ext-document", emptyFn:function () {
}, isSecure:/^https/i.test(window.location.protocol), isReady:false, enableGarbageCollector:true, enableListenerCollection:true, applyIf:function (b, a) {
    var c, d;
    if (b) {
        for (c in a) {
            if (b[c] === d) {
                b[c] = a[c]
            }
        }
    }
    return b
}, repaint:function () {
    var a = Ext.getBody().createChild({cls:"x-mask x-mask-transparent"});
    setTimeout(function () {
        a.remove()
    }, 0)
}, id:function (a, b) {
    a = Ext.getDom(a) || {};
    if (a === document) {
        a.id = this.documentId
    } else {
        if (a === window) {
            a.id = this.windowId
        }
    }
    a.id = a.id || ((b || "ext-gen") + (++Ext.idSeed));
    return a.id
}, extend:function () {
    var b = function (d) {
        for (var c in d) {
            if (!d.hasOwnProperty(c)) {
                continue
            }
            this[c] = d[c]
        }
    };
    var a = Object.prototype.constructor;
    return function (c, h, f) {
        if (Ext.isObject(h)) {
            f = h;
            h = c;
            c = f.constructor != a ? f.constructor : function () {
                h.apply(this, arguments)
            }
        }
        if (!h) {
            throw"Attempting to extend from a class which has not been loaded on the page."
        }
        var e = function () {
        }, d, g = h.prototype;
        e.prototype = g;
        d = c.prototype = new e();
        d.constructor = c;
        c.superclass = g;
        if (g.constructor == a) {
            g.constructor = h
        }
        c.override = function (i) {
            Ext.override(c, i)
        };
        d.superclass = d.supr = (function () {
            return g
        });
        d.override = b;
        d.proto = d;
        c.override(f);
        c.extend = function (i) {
            return Ext.extend(c, i)
        };
        return c
    }
}(), override:function (a, b) {
    Ext.apply(a.prototype, b)
}, namespace:function () {
    var e = arguments.length, d, f, c, a, h, g, b;
    for (d = 0; d < e; d++) {
        f = arguments[d];
        g = f.split(".");
        if (window.Ext) {
            b = window[g[0]] = Object(window[g[0]])
        } else {
            b = arguments.callee.caller.arguments[0]
        }
        for (a = 1, h = g.length; a < h; a++) {
            b = b[g[a]] = Object(b[g[a]])
        }
    }
    return b
}, urlEncode:function (f, d) {
    var b, a = [], c = encodeURIComponent;
    Ext.iterate(f, function (e, g) {
        b = Ext.isEmpty(g);
        Ext.each(b ? e : g, function (h) {
            a.push("&", c(e), "=", (!Ext.isEmpty(h) && (h != e || !b)) ? (Ext.isDate(h) ? Ext.encode(h).replace(/"/g, "") : c(h)) : "")
        })
    });
    if (!d) {
        a.shift();
        d = ""
    }
    return d + a.join("")
}, urlDecode:function (c, b) {
    if (Ext.isEmpty(c)) {
        return{}
    }
    var g = {}, f = c.split("&"), h = decodeURIComponent, a, e;
    Ext.each(f, function (d) {
        d = d.split("=");
        a = h(d[0]);
        e = h(d[1]);
        g[a] = b || !g[a] ? e : [].concat(g[a]).concat(e)
    });
    return g
}, htmlEncode:function (a) {
    return Ext.util.Format.htmlEncode(a)
}, htmlDecode:function (a) {
    return Ext.util.Format.htmlDecode(a)
}, urlAppend:function (a, b) {
    if (!Ext.isEmpty(b)) {
        return a + (a.indexOf("?") === -1 ? "?" : "&") + b
    }
    return a
}, toArray:function (c, b, a) {
    return Array.prototype.slice.call(c, b || 0, a || c.length)
}, each:function (e, d, c) {
    if (Ext.isEmpty(e, true)) {
        return 0
    }
    if (!Ext.isIterable(e) || Ext.isPrimitive(e)) {
        e = [e]
    }
    for (var b = 0, a = e.length; b < a; b++) {
        if (d.call(c || e[b], e[b], b, e) === false) {
            return b
        }
    }
    return true
}, iterate:function (c, b, a) {
    if (Ext.isEmpty(c)) {
        return
    }
    if (Ext.isIterable(c)) {
        Ext.each(c, b, a);
        return
    } else {
        if (Ext.isObject(c)) {
            for (var d in c) {
                if (c.hasOwnProperty(d)) {
                    if (b.call(a || c, d, c[d], c) === false) {
                        return
                    }
                }
            }
        }
    }
}, pluck:function (a, c) {
    var b = [];
    Ext.each(a, function (d) {
        b.push(d[c])
    });
    return b
}, getBody:function () {
    return Ext.get(document.body || false)
}, getHead:function () {
    var a;
    return function () {
        if (a == undefined) {
            a = Ext.get(DOC.getElementsByTagName("head")[0])
        }
        return a
    }
}(), getDoc:function () {
    return Ext.get(document)
}, getCmp:function (a) {
    return Ext.ComponentMgr.get(a)
}, getOrientation:function () {
    return window.innerHeight > window.innerWidth ? "portrait" : "landscape"
}, isIterable:function (a) {
    if (!a) {
        return false
    }
    if (Ext.isArray(a) || a.callee) {
        return true
    }
    if (/NodeList|HTMLCollection/.test(Object.prototype.toString.call(a))) {
        return true
    }
    return((typeof a.nextNode != "undefined" || a.item) && Ext.isNumber(a.length)) || false
}, num:function (b, a) {
    b = Number(Ext.isEmpty(b) || Ext.isArray(b) || typeof b == "boolean" || (typeof b == "string" && Ext.util.Format.trim(b).length == 0) ? NaN : b);
    return isNaN(b) ? a : b
}, isEmpty:function (d, a) {
    var b = d == null, c = (Ext.isArray(d) && !d.length), e = !a ? d === "" : false;
    return b || c || e
}, isArray:function (a) {
    return Object.prototype.toString.apply(a) === "[object Array]"
}, isDate:function (a) {
    return Object.prototype.toString.apply(a) === "[object Date]"
}, isObject:function (a) {
    return !!a && !a.tagName && Object.prototype.toString.call(a) === "[object Object]"
}, isPrimitive:function (a) {
    return Ext.isString(a) || Ext.isNumber(a) || Ext.isBoolean(a)
}, isFunction:function (a) {
    return Object.prototype.toString.apply(a) === "[object Function]"
}, isNumber:function (a) {
    return Object.prototype.toString.apply(a) === "[object Number]" && isFinite(a)
}, isString:function (a) {
    return typeof a === "string"
}, isBoolean:function (a) {
    return Object.prototype.toString.apply(a) === "[object Boolean]"
}, isElement:function (a) {
    return a ? !!a.tagName : false
}, isDefined:function (a) {
    return typeof a !== "undefined"
}, destroy:function () {
    var c = arguments.length, b, a;
    for (b = 0; b < c; b++) {
        a = arguments[b];
        if (a) {
            if (Ext.isArray(a)) {
                this.destroy.apply(this, a)
            } else {
                if (Ext.isFunction(a.destroy)) {
                    a.destroy()
                } else {
                    if (a.dom) {
                        a.remove()
                    }
                }
            }
        }
    }
}});
Ext.SSL_SECURE_URL = Ext.isSecure && "about:blank";
Ext.ns = Ext.namespace;
Ext.ns("Ext.util", "Ext.data", "Ext.list", "Ext.form", "Ext.menu", "Ext.state", "Ext.layout", "Ext.app", "Ext.ux", "Ext.plugins", "Ext.direct", "Ext.lib", "Ext.gesture");
Ext.util.Observable = Ext.extend(Object, {isObservable:true, constructor:function (a) {
    var b = this;
    Ext.apply(b, a);
    if (b.listeners) {
        b.on(b.listeners);
        delete b.listeners
    }
    b.events = b.events || {};
    if (this.bubbleEvents) {
        this.enableBubble(this.bubbleEvents)
    }
}, eventOptionsRe:/^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|element|vertical|horizontal)$/, addManagedListener:function (h, d, f, e, c) {
    var g = this, a = g.managedListeners = g.managedListeners || [], b;
    if (Ext.isObject(d)) {
        c = d;
        for (d in c) {
            if (!c.hasOwnProperty(d)) {
                continue
            }
            b = c[d];
            if (!g.eventOptionsRe.test(d)) {
                g.addManagedListener(h, d, b.fn || b, b.scope || c.scope, b.fn ? b : c)
            }
        }
    } else {
        a.push({item:h, ename:d, fn:f, scope:e, options:c});
        h.on(d, f, e, c)
    }
}, removeManagedListener:function (k, e, h, l) {
    var g = this, b, d, j, c, a, f;
    if (Ext.isObject(e)) {
        b = e;
        for (e in b) {
            if (!b.hasOwnProperty(e)) {
                continue
            }
            d = b[e];
            if (!g.eventOptionsRe.test(e)) {
                g.removeManagedListener(k, e, d.fn || d, d.scope || b.scope)
            }
        }
    }
    j = this.managedListeners ? this.managedListeners.slice() : [];
    a = j.length;
    for (f = 0; f < a; f++) {
        c = j[f];
        if (c.item === k && c.ename === e && (!h || c.fn === h) && (!l || c.scope === l)) {
            this.managedListeners.remove(c);
            k.un(c.ename, c.fn, c.scope)
        }
    }
}, fireEvent:function () {
    var h = this, c = Ext.toArray(arguments), e = c[0].toLowerCase(), d = true, g = h.events[e], b = h.eventQueue, f;
    if (h.eventsSuspended === true) {
        if (b) {
            b.push(c)
        }
        return false
    } else {
        if (g && Ext.isObject(g) && g.bubble) {
            if (g.fire.apply(g, c.slice(1)) === false) {
                return false
            }
            f = h.getBubbleTarget && h.getBubbleTarget();
            if (f && f.isObservable) {
                if (!f.events[e] || !Ext.isObject(f.events[e]) || !f.events[e].bubble) {
                    f.enableBubble(e)
                }
                return f.fireEvent.apply(f, c)
            }
        } else {
            if (g && Ext.isObject(g)) {
                c.shift();
                d = g.fire.apply(g, c)
            }
        }
    }
    return d
}, addListener:function (b, d, c, g) {
    var f = this, a, e;
    if (Ext.isObject(b)) {
        g = b;
        for (b in g) {
            if (!g.hasOwnProperty(b)) {
                continue
            }
            a = g[b];
            if (!f.eventOptionsRe.test(b)) {
                f.addListener(b, a.fn || a, a.scope || g.scope, a.fn ? a : g)
            }
        }
    } else {
        b = b.toLowerCase();
        f.events[b] = f.events[b] || true;
        e = f.events[b] || true;
        if (Ext.isBoolean(e)) {
            f.events[b] = e = new Ext.util.Event(f, b)
        }
        e.addListener(d, c, Ext.isObject(g) ? g : {})
    }
}, removeListener:function (b, d, c) {
    var f = this, a, e;
    if (Ext.isObject(b)) {
        var g = b;
        for (b in g) {
            if (!g.hasOwnProperty(b)) {
                continue
            }
            a = g[b];
            if (!f.eventOptionsRe.test(b)) {
                f.removeListener(b, a.fn || a, a.scope || g.scope)
            }
        }
    } else {
        b = b.toLowerCase();
        e = f.events[b];
        if (e.isEvent) {
            e.removeListener(d, c)
        }
    }
}, clearListeners:function () {
    var b = this.events, c, a;
    for (a in b) {
        if (!b.hasOwnProperty(a)) {
            continue
        }
        c = b[a];
        if (c.isEvent) {
            c.clearListeners()
        }
    }
    this.clearManagedListeners()
}, purgeListeners:function () {
    console.warn("MixedCollection: purgeListeners has been deprecated. Please use clearListeners.");
    return this.clearListeners.apply(this, arguments)
}, clearManagedListeners:function () {
    var b = this.managedListeners || [], d = b.length, c, a;
    for (c = 0; c < d; c++) {
        a = b[c];
        a.item.un(a.ename, a.fn, a.scope)
    }
    this.managedListener = []
}, purgeManagedListeners:function () {
    console.warn("MixedCollection: purgeManagedListeners has been deprecated. Please use clearManagedListeners.");
    return this.clearManagedListeners.apply(this, arguments)
}, addEvents:function (e) {
    var d = this;
    d.events = d.events || {};
    if (Ext.isString(e)) {
        var b = arguments, c = b.length;
        while (c--) {
            d.events[b[c]] = d.events[b[c]] || true
        }
    } else {
        Ext.applyIf(d.events, e)
    }
}, hasListener:function (a) {
    var b = this.events[a];
    return b.isEvent === true && b.listeners.length > 0
}, suspendEvents:function (a) {
    this.eventsSuspended = true;
    if (a && !this.eventQueue) {
        this.eventQueue = []
    }
}, resumeEvents:function () {
    var a = this, b = a.eventQueue || [];
    a.eventsSuspended = false;
    delete a.eventQueue;
    Ext.each(b, function (c) {
        a.fireEvent.apply(a, c)
    })
}, relayEvents:function (b, e, h) {
    h = h || "";
    var g = this, a = e.length, d, c;

    function f(i) {
        return function () {
            return g.fireEvent.apply(g, [h + i].concat(Array.prototype.slice.call(arguments, 0, -1)))
        }
    }

    for (d = 0, a = e.length; d < a; d++) {
        c = e[d].substr(h.length);
        g.events[c] = g.events[c] || true;
        b.on(c, f(c), g)
    }
}, enableBubble:function (a) {
    var b = this;
    if (!Ext.isEmpty(a)) {
        a = Ext.isArray(a) ? a : Ext.toArray(arguments);
        Ext.each(a, function (c) {
            c = c.toLowerCase();
            var d = b.events[c] || true;
            if (Ext.isBoolean(d)) {
                d = new Ext.util.Event(b, c);
                b.events[c] = d
            }
            d.bubble = true
        })
    }
}});
Ext.override(Ext.util.Observable, {on:Ext.util.Observable.prototype.addListener, un:Ext.util.Observable.prototype.removeListener, mon:Ext.util.Observable.prototype.addManagedListener, mun:Ext.util.Observable.prototype.removeManagedListener});
Ext.util.Observable.releaseCapture = function (a) {
    a.fireEvent = Ext.util.Observable.prototype.fireEvent
};
Ext.util.Observable.capture = function (c, b, a) {
    c.fireEvent = Ext.createInterceptor(c.fireEvent, b, a)
};
Ext.util.Observable.observe = function (a, b) {
    if (a) {
        if (!a.isObservable) {
            Ext.applyIf(a, new Ext.util.Observable());
            Ext.util.Observable.capture(a.prototype, a.fireEvent, a)
        }
        if (typeof b == "object") {
            a.on(b)
        }
        return a
    }
};
Ext.util.Observable.observeClass = Ext.util.Observable.observe;
Ext.util.Event = Ext.extend(Object, (function () {
    function b(e, f, g, d) {
        f.task = new Ext.util.DelayedTask();
        return function () {
            f.task.delay(g.buffer, e, d, Ext.toArray(arguments))
        }
    }

    function a(e, f, g, d) {
        return function () {
            var h = new Ext.util.DelayedTask();
            if (!f.tasks) {
                f.tasks = []
            }
            f.tasks.push(h);
            h.delay(g.delay || 10, e, d, Ext.toArray(arguments))
        }
    }

    function c(e, f, g, d) {
        return function () {
            f.ev.removeListener(f.fn, d);
            return e.apply(d, arguments)
        }
    }

    return{isEvent:true, constructor:function (e, d) {
        this.name = d;
        this.observable = e;
        this.listeners = []
    }, addListener:function (f, e, d) {
        var g = this, h;
        e = e || g.observable;
        if (!g.isListening(f, e)) {
            h = g.createListener(f, e, d);
            if (g.firing) {
                g.listeners = g.listeners.slice(0)
            }
            g.listeners.push(h)
        }
    }, createListener:function (f, e, h) {
        h = h || {};
        e = e || this.observable;
        var g = {fn:f, scope:e, o:h, ev:this}, d = f;
        if (h.delay) {
            d = a(d, g, h, e)
        }
        if (h.buffer) {
            d = b(d, g, h, e)
        }
        if (h.single) {
            d = c(d, g, h, e)
        }
        g.fireFn = d;
        return g
    }, findListener:function (h, g) {
        var f = this.listeners, d = f.length, j, e;
        while (d--) {
            j = f[d];
            if (j) {
                e = j.scope;
                if (j.fn == h && (e == g || e == this.observable)) {
                    return d
                }
            }
        }
        return -1
    }, isListening:function (e, d) {
        return this.findListener(e, d) !== -1
    }, removeListener:function (g, f) {
        var h = this, e, i, d;
        e = h.findListener(g, f);
        if (e != -1) {
            i = h.listeners[e];
            if (h.firing) {
                h.listeners = h.listeners.slice(0)
            }
            if (i.task) {
                i.task.cancel();
                delete i.task
            }
            d = i.tasks && i.tasks.length;
            if (d) {
                while (d--) {
                    i.tasks[d].cancel()
                }
                delete i.tasks
            }
            h.listeners.splice(e, 1);
            return true
        }
        return false
    }, clearListeners:function () {
        var e = this.listeners, d = e.length;
        while (d--) {
            this.removeListener(e[d].fn, e[d].scope)
        }
    }, fire:function () {
        var h = this, f = h.listeners, g = f.length, e, d, j;
        if (g > 0) {
            h.firing = true;
            for (e = 0; e < g; e++) {
                j = f[e];
                d = arguments.length ? Array.prototype.slice.call(arguments, 0) : [];
                if (j.o) {
                    d.push(j.o)
                }
                if (j && j.fireFn.apply(j.scope || h.observable, d) === false) {
                    return(h.firing = false)
                }
            }
        }
        h.firing = false;
        return true
    }}
})());
Ext.util.Stateful = Ext.extend(Ext.util.Observable, {editing:false, dirty:false, persistanceProperty:"data", constructor:function (a) {
    Ext.applyIf(this, {data:{}});
    this.modified = {};
    this[this.persistanceProperty] = {};
    Ext.util.Stateful.superclass.constructor.call(this, a)
}, get:function (a) {
    return this[this.persistanceProperty][a]
}, set:function (j, f) {
    var d = this, c = d.fields, h = d.modified, b = [], e, g, a;
    if (arguments.length == 1 && Ext.isObject(j)) {
        for (g in j) {
            if (!j.hasOwnProperty(g)) {
                continue
            }
            e = c.get(g);
            if (e && e.convert !== e.type.convert) {
                b.push(g);
                continue
            }
            d.set(g, j[g])
        }
        for (a = 0; a < b.length; a++) {
            e = b[a];
            d.set(e, j[e])
        }
    } else {
        if (c) {
            e = c.get(j);
            if (e && e.convert) {
                f = e.convert(f, d)
            }
        }
        d[d.persistanceProperty][j] = f;
        if (e && e.persist && !d.isEqual(currentValue, f)) {
            if (d.isModified(j)) {
                if (d.isEqual(h[j], f)) {
                    delete h[j];
                    d.dirty = false;
                    for (g in h) {
                        if (h.hasOwnProperty(g)) {
                            d.dirty = true;
                            break
                        }
                    }
                }
            } else {
                d.dirty = true;
                h[j] = currentValue
            }
        }
        if (!d.editing) {
            d.afterEdit()
        }
    }
}, getChanges:function () {
    var a = this.modified, b = {}, c;
    for (c in a) {
        if (a.hasOwnProperty(c)) {
            b[c] = this[this.persistanceProperty][c]
        }
    }
    return b
}, isModified:function (a) {
    return !!(this.modified && this.modified.hasOwnProperty(a))
}, setDirty:function () {
    this.dirty = true;
    if (!this.modified) {
        this.modified = {}
    }
    this.fields.each(function (a) {
        this.modified[a.name] = this[this.persistanceProperty][a.name]
    }, this)
}, markDirty:function () {
    throw new Error("Stateful: markDirty has been deprecated. Please use setDirty.")
}, reject:function (a) {
    var b = this.modified, c;
    for (c in b) {
        if (!b.hasOwnProperty(c)) {
            continue
        }
        if (typeof b[c] != "function") {
            this[this.persistanceProperty][c] = b[c]
        }
    }
    this.dirty = false;
    this.editing = false;
    delete this.modified;
    if (a !== true) {
        this.afterReject()
    }
}, commit:function (a) {
    this.dirty = false;
    this.editing = false;
    delete this.modified;
    if (a !== true) {
        this.afterCommit()
    }
}, copy:function (a) {
    return new this.constructor(Ext.apply({}, this[this.persistanceProperty]), a || this.internalId)
}});
Ext.util.HashMap = Ext.extend(Ext.util.Observable, {constructor:function (a) {
    this.addEvents("add", "clear", "remove", "replace");
    Ext.util.HashMap.superclass.constructor.call(this, a);
    this.clear(true)
}, getCount:function () {
    return this.length
}, getData:function (a, b) {
    if (b === undefined) {
        b = a;
        a = this.getKey(b)
    }
    return[a, b]
}, getKey:function (a) {
    return a.id
}, add:function (a, d) {
    var b = this, c;
    if (b.containsKey(a)) {
        throw new Error("This key already exists in the HashMap")
    }
    c = this.getData(a, d);
    a = c[0];
    d = c[1];
    b.map[a] = d;
    ++b.length;
    b.fireEvent("add", b, a, d);
    return d
}, replace:function (b, d) {
    var c = this, e = c.map, a;
    if (!c.containsKey(b)) {
        c.add(b, d)
    }
    a = e[b];
    e[b] = d;
    c.fireEvent("replace", c, b, d, a);
    return d
}, remove:function (b) {
    var a = this.findKey(b);
    if (a !== undefined) {
        return this.removeByKey(a)
    }
    return false
}, removeByKey:function (a) {
    var b = this, c;
    if (b.containsKey(a)) {
        c = b.map[a];
        delete b.map[a];
        --b.length;
        b.fireEvent("remove", b, a, c);
        return true
    }
    return false
}, get:function (a) {
    return this.map[a]
}, clear:function (a) {
    var b = this;
    b.map = {};
    b.length = 0;
    if (a !== true) {
        b.fireEvent("clear", b)
    }
    return b
}, containsKey:function (a) {
    return this.map[a] !== undefined
}, contains:function (a) {
    return this.containsKey(this.findKey(a))
}, getKeys:function () {
    return this.getArray(true)
}, getValues:function () {
    return this.getArray(false)
}, getArray:function (d) {
    var a = [], b, c = this.map;
    for (b in c) {
        if (c.hasOwnProperty(b)) {
            a.push(d ? b : c[b])
        }
    }
    return a
}, each:function (d, c) {
    var a = Ext.apply({}, this.map), b, e = this.length;
    c = c || this;
    for (b in a) {
        if (a.hasOwnProperty(b)) {
            if (d.call(c, b, a[b], e) === false) {
                break
            }
        }
    }
    return this
}, clone:function () {
    var c = new Ext.util.HashMap(), b = this.map, a;
    c.suspendEvents();
    for (a in b) {
        if (b.hasOwnProperty(a)) {
            c.add(a, b[a])
        }
    }
    c.resumeEvents();
    return c
}, findKey:function (b) {
    var a, c = this.map;
    for (a in c) {
        if (c.hasOwnProperty(a) && c[a] === b) {
            return a
        }
    }
    return undefined
}});
Ext.util.MixedCollection = function (b, a) {
    this.items = [];
    this.map = {};
    this.keys = [];
    this.length = 0;
    this.addEvents("clear", "add", "replace", "remove", "sort");
    this.allowFunctions = b === true;
    if (a) {
        this.getKey = a
    }
    Ext.util.MixedCollection.superclass.constructor.call(this)
};
Ext.extend(Ext.util.MixedCollection, Ext.util.Observable, {allowFunctions:false, add:function (b, d) {
    var e = d, c = b;
    if (arguments.length == 1) {
        e = c;
        c = this.getKey(e)
    }
    if (typeof c != "undefined" && c !== null) {
        var a = this.map[c];
        if (typeof a != "undefined") {
            return this.replace(c, e)
        }
        this.map[c] = e
    }
    this.length++;
    this.items.push(e);
    this.keys.push(c);
    this.fireEvent("add", this.length - 1, e, c);
    return e
}, getKey:function (a) {
    return a.id
}, replace:function (c, d) {
    if (arguments.length == 1) {
        d = arguments[0];
        c = this.getKey(d)
    }
    var a = this.map[c];
    if (typeof c == "undefined" || c === null || typeof a == "undefined") {
        return this.add(c, d)
    }
    var b = this.indexOfKey(c);
    this.items[b] = d;
    this.map[c] = d;
    this.fireEvent("replace", c, a, d);
    return d
}, addAll:function (e) {
    if (arguments.length > 1 || Ext.isArray(e)) {
        var b = arguments.length > 1 ? arguments : e;
        for (var d = 0, a = b.length; d < a; d++) {
            this.add(b[d])
        }
    } else {
        for (var c in e) {
            if (!e.hasOwnProperty(c)) {
                continue
            }
            if (this.allowFunctions || typeof e[c] != "function") {
                this.add(c, e[c])
            }
        }
    }
}, each:function (e, d) {
    var b = [].concat(this.items);
    for (var c = 0, a = b.length; c < a; c++) {
        if (e.call(d || b[c], b[c], c, a) === false) {
            break
        }
    }
}, eachKey:function (d, c) {
    for (var b = 0, a = this.keys.length; b < a; b++) {
        d.call(c || window, this.keys[b], this.items[b], b, a)
    }
}, findBy:function (d, c) {
    for (var b = 0, a = this.items.length; b < a; b++) {
        if (d.call(c || window, this.items[b], this.keys[b])) {
            return this.items[b]
        }
    }
    return null
}, insert:function (a, b, d) {
    var c = b, e = d;
    if (arguments.length == 2) {
        e = c;
        c = this.getKey(e)
    }
    if (this.containsKey(c)) {
        this.suspendEvents();
        this.removeByKey(c);
        this.resumeEvents()
    }
    if (a >= this.length) {
        return this.add(c, e)
    }
    this.length++;
    this.items.splice(a, 0, e);
    if (typeof c != "undefined" && c !== null) {
        this.map[c] = e
    }
    this.keys.splice(a, 0, c);
    this.fireEvent("add", a, e, c);
    return e
}, remove:function (a) {
    return this.removeAt(this.indexOf(a))
}, removeAll:function (a) {
    Ext.each(a || [], function (b) {
        this.remove(b)
    }, this);
    return this
}, removeAt:function (a) {
    if (a < this.length && a >= 0) {
        this.length--;
        var c = this.items[a];
        this.items.splice(a, 1);
        var b = this.keys[a];
        if (typeof b != "undefined") {
            delete this.map[b]
        }
        this.keys.splice(a, 1);
        this.fireEvent("remove", c, b);
        return c
    }
    return false
}, removeByKey:function (a) {
    return this.removeAt(this.indexOfKey(a))
}, removeKey:function () {
    console.warn("MixedCollection: removeKey has been deprecated. Please use removeByKey.");
    return this.removeByKey.apply(this, arguments)
}, getCount:function () {
    return this.length
}, indexOf:function (a) {
    return this.items.indexOf(a)
}, indexOfKey:function (a) {
    return this.keys.indexOf(a)
}, get:function (b) {
    var a = this.map[b], c = a !== undefined ? a : (typeof b == "number") ? this.items[b] : undefined;
    return typeof c != "function" || this.allowFunctions ? c : null
}, item:function () {
    console.warn("MixedCollection: item has been deprecated. Please use get.");
    return this.get.apply(this, arguments)
}, getAt:function (a) {
    return this.items[a]
}, itemAt:function () {
    console.warn("MixedCollection: itemAt has been deprecated. Please use getAt.");
    return this.getAt.apply(this, arguments)
}, getByKey:function (a) {
    return this.map[a]
}, key:function () {
    console.warn("MixedCollection: key has been deprecated. Please use getByKey.");
    return this.getByKey.apply(this, arguments)
}, contains:function (a) {
    return this.indexOf(a) != -1
}, containsKey:function (a) {
    return typeof this.map[a] != "undefined"
}, clear:function () {
    this.length = 0;
    this.items = [];
    this.keys = [];
    this.map = {};
    this.fireEvent("clear")
}, first:function () {
    return this.items[0]
}, last:function () {
    return this.items[this.length - 1]
}, _sort:function (j, a, h) {
    var d, e, b = String(a).toUpperCase() == "DESC" ? -1 : 1, g = [], k = this.keys, f = this.items;
    h = h || function (i, c) {
        return i - c
    };
    for (d = 0, e = f.length; d < e; d++) {
        g[g.length] = {key:k[d], value:f[d], index:d}
    }
    g.sort(function (i, c) {
        var l = h(i[j], c[j]) * b;
        if (l === 0) {
            l = (i.index < c.index ? -1 : 1)
        }
        return l
    });
    for (d = 0, e = g.length; d < e; d++) {
        f[d] = g[d].value;
        k[d] = g[d].key
    }
    this.fireEvent("sort", this)
}, sort:function (c, e) {
    var d = c;
    if (Ext.isString(c)) {
        d = [new Ext.util.Sorter({property:c, direction:e || "ASC"})]
    } else {
        if (c instanceof Ext.util.Sorter) {
            d = [c]
        } else {
            if (Ext.isObject(c)) {
                d = [new Ext.util.Sorter(c)]
            }
        }
    }
    var b = d.length;
    if (b == 0) {
        return
    }
    var a = function (h, g) {
        var f = d[0].sort(h, g), k = d.length, j;
        for (j = 1; j < k; j++) {
            f = f || d[j].sort.call(this, h, g)
        }
        return f
    };
    this.sortBy(a)
}, sortBy:function (c) {
    var b = this.items, f = this.keys, e = b.length, a = [], d;
    for (d = 0; d < e; d++) {
        a[d] = {key:f[d], value:b[d], index:d}
    }
    a.sort(function (h, g) {
        var i = c(h.value, g.value);
        if (i === 0) {
            i = (h.index < g.index ? -1 : 1)
        }
        return i
    });
    for (d = 0; d < e; d++) {
        b[d] = a[d].value;
        f[d] = a[d].key
    }
    this.fireEvent("sort", this)
}, reorder:function (d) {
    this.suspendEvents();
    var b = this.items, c = 0, f = b.length, a = [], e = [], g;
    for (g in d) {
        a[d[g]] = b[g]
    }
    for (c = 0; c < f; c++) {
        if (d[c] == undefined) {
            e.push(b[c])
        }
    }
    for (c = 0; c < f; c++) {
        if (a[c] == undefined) {
            a[c] = e.shift()
        }
    }
    this.clear();
    this.addAll(a);
    this.resumeEvents();
    this.fireEvent("sort", this)
}, sortByKey:function (a, b) {
    this._sort("key", a, b || function (d, c) {
        var f = String(d).toUpperCase(), e = String(c).toUpperCase();
        return f > e ? 1 : (f < e ? -1 : 0)
    })
}, keySort:function () {
    console.warn("MixedCollection: keySort has been deprecated. Please use sortByKey.");
    return this.sortByKey.apply(this, arguments)
}, getRange:function (e, a) {
    var b = this.items;
    if (b.length < 1) {
        return[]
    }
    e = e || 0;
    a = Math.min(typeof a == "undefined" ? this.length - 1 : a, this.length - 1);
    var c, d = [];
    if (e <= a) {
        for (c = e; c <= a; c++) {
            d[d.length] = b[c]
        }
    } else {
        for (c = e; c >= a; c--) {
            d[d.length] = b[c]
        }
    }
    return d
}, filter:function (d, c, f, a) {
    var b = [];
    if (Ext.isString(d)) {
        b.push(new Ext.util.Filter({property:d, value:c, anyMatch:f, caseSensitive:a}))
    } else {
        if (Ext.isArray(d) || d instanceof Ext.util.Filter) {
            b = b.concat(d)
        }
    }
    var e = function (g) {
        var m = true, n = b.length, h;
        for (h = 0; h < n; h++) {
            var l = b[h], k = l.filterFn, j = l.scope;
            m = m && k.call(j, g)
        }
        return m
    };
    return this.filterBy(e)
}, filterBy:function (e, d) {
    var a = new Ext.util.MixedCollection(), g = this.keys, b = this.items, f = b.length, c;
    a.getKey = this.getKey;
    for (c = 0; c < f; c++) {
        if (e.call(d || this, b[c], g[c])) {
            a.add(g[c], b[c])
        }
    }
    return a
}, findIndex:function (c, b, e, d, a) {
    if (Ext.isEmpty(b, false)) {
        return -1
    }
    b = this.createValueMatcher(b, d, a);
    return this.findIndexBy(function (f) {
        return f && b.test(f[c])
    }, null, e)
}, findIndexBy:function (f, e, g) {
    var b = this.keys, d = this.items;
    for (var c = (g || 0), a = d.length; c < a; c++) {
        if (f.call(e || this, d[c], b[c])) {
            return c
        }
    }
    return -1
}, createValueMatcher:function (c, e, a, b) {
    if (!c.exec) {
        var d = Ext.util.Format.escapeRegex;
        c = String(c);
        if (e === true) {
            c = d(c)
        } else {
            c = "^" + d(c);
            if (b === true) {
                c += "$"
            }
        }
        c = new RegExp(c, a ? "" : "i")
    }
    return c
}, clone:function () {
    var e = new Ext.util.MixedCollection();
    var b = this.keys, d = this.items;
    for (var c = 0, a = d.length; c < a; c++) {
        e.add(b[c], d[c])
    }
    e.getKey = this.getKey;
    return e
}});
Ext.AbstractManager = Ext.extend(Object, {typeName:"type", constructor:function (a) {
    Ext.apply(this, a || {});
    this.all = new Ext.util.HashMap();
    this.types = {}
}, get:function (a) {
    return this.all.get(a)
}, register:function (a) {
    this.all.add(a)
}, unregister:function (a) {
    this.all.remove(a)
}, registerType:function (b, a) {
    this.types[b] = a;
    a[this.typeName] = b
}, isRegistered:function (a) {
    return this.types[a] !== undefined
}, create:function (a, d) {
    var b = a[this.typeName] || a.type || d, c = this.types[b];
    if (c == undefined) {
        throw new Error(Ext.util.Format.format("The '{0}' type has not been registered with this manager", b))
    }
    return new c(a)
}, onAvailable:function (d, c, b) {
    var a = this.all;
    a.on("add", function (e, f) {
        if (f.id == d) {
            c.call(b || f, f);
            a.un("add", c, b)
        }
    })
}, each:function (b, a) {
    this.all.each(b, a || this)
}, getCount:function () {
    return this.all.getCount()
}});
Ext.util.DelayedTask = function (d, c, a) {
    var e = this, f, b = function () {
        clearInterval(f);
        f = null;
        d.apply(c, a || [])
    };
    this.delay = function (h, j, i, g) {
        e.cancel();
        d = j || d;
        c = i || c;
        a = g || a;
        f = setInterval(b, h)
    };
    this.cancel = function () {
        if (f) {
            clearInterval(f);
            f = null
        }
    }
};
Ext.util.GeoLocation = Ext.extend(Ext.util.Observable, {autoUpdate:true, latitude:null, longitude:null, accuracy:null, altitude:null, altitudeAccuracy:null, heading:null, speed:null, timestamp:null, allowHighAccuracy:false, timeout:Infinity, maximumAge:0, setMaximumAge:function (a) {
    this.maximumAge = a;
    this.setAutoUpdate(this.autoUpdate)
}, setTimeout:function (a) {
    this.timeout = a;
    this.setAutoUpdate(this.autoUpdate)
}, setAllowHighAccuracy:function (a) {
    this.allowHighAccuracy = a;
    this.setAutoUpdate(this.autoUpdate)
}, provider:null, watchOperation:null, constructor:function (a) {
    Ext.apply(this, a);
    this.coords = this;
    if (Ext.supports.GeoLocation) {
        this.provider = this.provider || (navigator.geolocation ? navigator.geolocation : (window.google || {}).gears ? google.gears.factory.create("beta.geolocation") : null)
    }
    this.addEvents("update", "locationerror", "locationupdate");
    Ext.util.GeoLocation.superclass.constructor.call(this);
    if (this.autoUpdate) {
        var b = this;
        setTimeout(function () {
            b.setAutoUpdate(b.autoUpdate)
        }, 0)
    }
}, setAutoUpdate:function (a) {
    if (this.watchOperation !== null) {
        this.provider.clearWatch(this.watchOperation);
        this.watchOperation = null
    }
    if (!a) {
        return true
    }
    if (!Ext.supports.GeoLocation) {
        this.fireEvent("locationerror", this, false, false, true, null);
        return false
    }
    try {
        this.watchOperation = this.provider.watchPosition(Ext.createDelegate(this.fireUpdate, this), Ext.createDelegate(this.fireError, this), this.parseOptions())
    } catch (b) {
        this.autoUpdate = false;
        this.fireEvent("locationerror", this, false, false, true, b.message);
        return false
    }
    return true
}, updateLocation:function (g, a, c) {
    var b = this;
    var f = function (h, e) {
        if (e) {
            b.fireError(e)
        } else {
            b.fireEvent("locationerror", b, false, false, true, h)
        }
        if (g) {
            g.call(a || b, null, b)
        }
        b.fireEvent("update", false, b)
    };
    if (!Ext.supports.GeoLocation) {
        setTimeout(function () {
            f(null)
        }, 0);
        return
    }
    try {
        this.provider.getCurrentPosition(function (e) {
            b.fireUpdate(e);
            if (g) {
                g.call(a || b, b, b)
            }
            b.fireEvent("update", b, b)
        }, function (e) {
            f(null, e)
        }, c ? c : this.parseOptions())
    } catch (d) {
        setTimeout(function () {
            f(d.message)
        }, 0)
    }
}, fireUpdate:function (a) {
    this.timestamp = a.timestamp;
    this.latitude = a.coords.latitude;
    this.longitude = a.coords.longitude;
    this.accuracy = a.coords.accuracy;
    this.altitude = a.coords.altitude;
    this.altitudeAccuracy = a.coords.altitudeAccuracy;
    this.heading = typeof a.coords.heading == "undefined" ? null : a.coords.heading;
    this.speed = typeof a.coords.speed == "undefined" ? null : a.coords.speed;
    this.fireEvent("locationupdate", this)
}, fireError:function (a) {
    this.fireEvent("locationerror", this, a.code == a.TIMEOUT, a.code == a.PERMISSION_DENIED, a.code == a.POSITION_UNAVAILABLE, a.message == undefined ? null : a.message)
}, parseOptions:function () {
    var a = {maximumAge:this.maximumAge, allowHighAccuracy:this.allowHighAccuracy};
    if (this.timeout !== Infinity) {
        a.timeout = this.timeout
    }
    return a
}, getLocation:function (c, a) {
    var b = this;
    if (this.latitude !== null) {
        c.call(a || b, b, b)
    } else {
        b.updateLocation(c, a)
    }
}});
Ext.util.Region = Ext.extend(Object, {constructor:function (d, f, a, c) {
    var e = this;
    e.top = d;
    e[1] = d;
    e.right = f;
    e.bottom = a;
    e.left = c;
    e[0] = c
}, contains:function (b) {
    var a = this;
    return(b.left >= a.left && b.right <= a.right && b.top >= a.top && b.bottom <= a.bottom)
}, intersect:function (g) {
    var f = this, d = Math.max(f.top, g.top), e = Math.min(f.right, g.right), a = Math.min(f.bottom, g.bottom), c = Math.max(f.left, g.left);
    if (a > d && e > c) {
        return new Ext.util.Region(d, e, a, c)
    } else {
        return false
    }
}, union:function (g) {
    var f = this, d = Math.min(f.top, g.top), e = Math.max(f.right, g.right), a = Math.max(f.bottom, g.bottom), c = Math.min(f.left, g.left);
    return new Ext.util.Region(d, e, a, c)
}, constrainTo:function (b) {
    var a = this, c = Ext.util.Numbers.constrain;
    a.top = c(a.top, b.top, b.bottom);
    a.bottom = c(a.bottom, b.top, b.bottom);
    a.left = c(a.left, b.left, b.right);
    a.right = c(a.right, b.left, b.right);
    return a
}, adjust:function (d, f, a, c) {
    var e = this;
    e.top += d;
    e.left += c;
    e.right += f;
    e.bottom += a;
    return e
}, getOutOfBoundOffset:function (a, b) {
    if (!Ext.isObject(a)) {
        if (a == "x") {
            return this.getOutOfBoundOffsetX(b)
        } else {
            return this.getOutOfBoundOffsetY(b)
        }
    } else {
        b = a;
        var c = new Ext.util.Offset();
        c.x = this.getOutOfBoundOffsetX(b.x);
        c.y = this.getOutOfBoundOffsetY(b.y);
        return c
    }
}, getOutOfBoundOffsetX:function (a) {
    if (a <= this.left) {
        return this.left - a
    } else {
        if (a >= this.right) {
            return this.right - a
        }
    }
    return 0
}, getOutOfBoundOffsetY:function (a) {
    if (a <= this.top) {
        return this.top - a
    } else {
        if (a >= this.bottom) {
            return this.bottom - a
        }
    }
    return 0
}, isOutOfBound:function (a, b) {
    if (!Ext.isObject(a)) {
        if (a == "x") {
            return this.isOutOfBoundX(b)
        } else {
            return this.isOutOfBoundY(b)
        }
    } else {
        b = a;
        return(this.isOutOfBoundX(b.x) || this.isOutOfBoundY(b.y))
    }
}, isOutOfBoundX:function (a) {
    return(a < this.left || a > this.right)
}, isOutOfBoundY:function (a) {
    return(a < this.top || a > this.bottom)
}, restrict:function (b, d, a) {
    if (Ext.isObject(b)) {
        var c;
        a = d;
        d = b;
        if (d.copy) {
            c = d.copy()
        } else {
            c = {x:d.x, y:d.y}
        }
        c.x = this.restrictX(d.x, a);
        c.y = this.restrictY(d.y, a);
        return c
    } else {
        if (b == "x") {
            return this.restrictX(d, a)
        } else {
            return this.restrictY(d, a)
        }
    }
}, restrictX:function (b, a) {
    if (!a) {
        a = 1
    }
    if (b <= this.left) {
        b -= (b - this.left) * a
    } else {
        if (b >= this.right) {
            b -= (b - this.right) * a
        }
    }
    return b
}, restrictY:function (b, a) {
    if (!a) {
        a = 1
    }
    if (b <= this.top) {
        b -= (b - this.top) * a
    } else {
        if (b >= this.bottom) {
            b -= (b - this.bottom) * a
        }
    }
    return b
}, getSize:function () {
    return{width:this.right - this.left, height:this.bottom - this.top}
}, copy:function () {
    return new Ext.util.Region(this.top, this.right, this.bottom, this.left)
}, toString:function () {
    return"Region[" + this.top + "," + this.right + "," + this.bottom + "," + this.left + "]"
}, translateBy:function (a) {
    this.left += a.x;
    this.right += a.x;
    this.top += a.y;
    this.bottom += a.y;
    return this
}, round:function () {
    this.top = Math.round(this.top);
    this.right = Math.round(this.right);
    this.bottom = Math.round(this.bottom);
    this.left = Math.round(this.left);
    return this
}, equals:function (a) {
    return(this.top == a.top && this.right == a.right && this.bottom == a.bottom && this.left == a.left)
}});
Ext.util.Region.getRegion = function (a) {
    return Ext.fly(a).getPageBox(true)
};
Ext.util.Region.from = function (a) {
    return new Ext.util.Region(a.top, a.right, a.bottom, a.left)
};
Ext.util.Point = Ext.extend(Object, {constructor:function (a, b) {
    this.x = (a != null && !isNaN(a)) ? a : 0;
    this.y = (b != null && !isNaN(b)) ? b : 0;
    return this
}, copy:function () {
    return new Ext.util.Point(this.x, this.y)
}, copyFrom:function (a) {
    this.x = a.x;
    this.y = a.y;
    return this
}, toString:function () {
    return"Point[" + this.x + "," + this.y + "]"
}, equals:function (a) {
    return(this.x == a.x && this.y == a.y)
}, isWithin:function (b, a) {
    if (!Ext.isObject(a)) {
        a = {x:a};
        a.y = a.x
    }
    return(this.x <= b.x + a.x && this.x >= b.x - a.x && this.y <= b.y + a.y && this.y >= b.y - a.y)
}, translate:function (a, b) {
    if (a != null && !isNaN(a)) {
        this.x += a
    }
    if (b != null && !isNaN(b)) {
        this.y += b
    }
}, roundedEquals:function (a) {
    return(Math.round(this.x) == Math.round(a.x) && Math.round(this.y) == Math.round(a.y))
}});
Ext.util.Point.fromEvent = function (c) {
    var b = (c.changedTouches && c.changedTouches.length > 0) ? c.changedTouches[0] : c;
    return new Ext.util.Point(b.pageX, b.pageY)
};
Ext.util.Offset = Ext.extend(Object, {constructor:function (a, b) {
    this.x = (a != null && !isNaN(a)) ? a : 0;
    this.y = (b != null && !isNaN(b)) ? b : 0;
    return this
}, copy:function () {
    return new Ext.util.Offset(this.x, this.y)
}, copyFrom:function (a) {
    this.x = a.x;
    this.y = a.y
}, toString:function () {
    return"Offset[" + this.x + "," + this.y + "]"
}, equals:function (a) {
    if (!(a instanceof Ext.util.Offset)) {
        throw new Error("offset must be an instance of Ext.util.Offset")
    }
    return(this.x == a.x && this.y == a.y)
}, round:function (b) {
    if (!isNaN(b)) {
        var a = Math.pow(10, b);
        this.x = Math.round(this.x * a) / a;
        this.y = Math.round(this.y * a) / a
    } else {
        this.x = Math.round(this.x);
        this.y = Math.round(this.y)
    }
}, isZero:function () {
    return this.x == 0 && this.y == 0
}});
Ext.util.Offset.fromObject = function (a) {
    return new Ext.util.Offset(a.x, a.y)
};
Ext.Template = Ext.extend(Object, {constructor:function (d) {
    var f = this, b = arguments, a = [], g, c, e;
    f.initialConfig = {};
    if (Ext.isArray(d)) {
        d = d.join("")
    } else {
        if (b.length > 1) {
            for (c = 0, e = b.length; c < e; c++) {
                g = b[c];
                if (typeof g == "object") {
                    Ext.apply(f.initialConfig, g);
                    Ext.apply(f, g)
                } else {
                    a.push(g)
                }
            }
            d = a.join("")
        }
    }
    f.html = d;
    if (f.compiled) {
        f.compile()
    }
}, isTemplate:true, disableFormats:false, re:/\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g, applyTemplate:function (a) {
    var f = this, c = f.disableFormats !== true, e = Ext.util.Format, b = f;
    if (f.compiled) {
        return f.compiled(a)
    }
    function d(g, i, j, h) {
        if (j && c) {
            if (h) {
                h = [a[i]].concat(new Function("return [" + h + "];")())
            } else {
                h = [a[i]]
            }
            if (j.substr(0, 5) == "this.") {
                return b[j.substr(5)].apply(b, h)
            } else {
                return e[j].apply(e, h)
            }
        } else {
            return a[i] !== undefined ? a[i] : ""
        }
    }

    return f.html.replace(f.re, d)
}, set:function (a, c) {
    var b = this;
    b.html = a;
    b.compiled = null;
    return c ? b.compile() : b
}, compileARe:/\\/g, compileBRe:/(\r\n|\n)/g, compileCRe:/'/g, compile:function () {
    var me = this, fm = Ext.util.Format, useFormat = me.disableFormats !== true, body, bodyReturn;

    function fn(m, name, format, args) {
        if (format && useFormat) {
            args = args ? "," + args : "";
            if (format.substr(0, 5) != "this.") {
                format = "fm." + format + "("
            } else {
                format = "this." + format.substr(5) + "("
            }
        } else {
            args = "";
            format = "(values['" + name + "'] == undefined ? '' : "
        }
        return"'," + format + "values['" + name + "']" + args + ") ,'"
    }

    bodyReturn = me.html.replace(me.compileARe, "\\\\").replace(me.compileBRe, "\\n").replace(me.compileCRe, "\\'").replace(me.re, fn);
    body = "this.compiled = function(values){ return ['" + bodyReturn + "'].join('');};";
    eval(body);
    return me
}, insertFirst:function (b, a, c) {
    return this.doInsert("afterBegin", b, a, c)
}, insertBefore:function (b, a, c) {
    return this.doInsert("beforeBegin", b, a, c)
}, insertAfter:function (b, a, c) {
    return this.doInsert("afterEnd", b, a, c)
}, append:function (b, a, c) {
    return this.doInsert("beforeEnd", b, a, c)
}, doInsert:function (c, e, b, a) {
    e = Ext.getDom(e);
    var d = Ext.DomHelper.insertHtml(c, e, this.applyTemplate(b));
    return a ? Ext.get(d, true) : d
}, overwrite:function (b, a, c) {
    b = Ext.getDom(b);
    b.innerHTML = this.applyTemplate(a);
    return c ? Ext.get(b.firstChild, true) : b.firstChild
}});
Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;
Ext.Template.from = function (b, a) {
    b = Ext.getDom(b);
    return new Ext.Template(b.value || b.innerHTML, a || "")
};
Ext.XTemplate = Ext.extend(Ext.Template, {argsRe:/<tpl\b[^>]*>((?:(?=([^<]+))\2|<(?!tpl\b[^>]*>))*?)<\/tpl>/, nameRe:/^<tpl\b[^>]*?for="(.*?)"/, ifRe:/^<tpl\b[^>]*?if="(.*?)"/, execRe:/^<tpl\b[^>]*?exec="(.*?)"/, constructor:function () {
    Ext.XTemplate.superclass.constructor.apply(this, arguments);
    var y = this, h = y.html, v = y.argsRe, c = y.nameRe, t = y.ifRe, x = y.execRe, o = 0, j = [], n = "values", w = "parent", k = "xindex", l = "xcount", d = "return ", b = "with(values){ ", p, f, u, a, e, g, q, z, s;
    h = ["<tpl>", h, "</tpl>"].join("");
    while ((p = h.match(v))) {
        e = null;
        g = null;
        q = null;
        f = p[0].match(c);
        u = p[0].match(t);
        a = p[0].match(x);
        e = u ? u[1] : null;
        if (e) {
            g = new Function(n, w, k, l, b + "try{" + d + Ext.util.Format.htmlDecode(e) + ";}catch(e){return;}}")
        }
        e = a ? a[1] : null;
        if (e) {
            q = new Function(n, w, k, l, b + Ext.util.Format.htmlDecode(e) + ";}")
        }
        z = f ? f[1] : null;
        if (z) {
            if (z === ".") {
                z = n
            } else {
                if (z === "..") {
                    z = w
                }
            }
            z = new Function(n, w, "try{" + b + d + z + ";}}catch(e){return;}")
        }
        j.push({id:o, target:z, exec:q, test:g, body:p[1] || ""});
        h = h.replace(p[0], "{xtpl" + o + "}");
        o = o + 1
    }
    for (s = j.length - 1; s >= 0; --s) {
        y.compileTpl(j[s])
    }
    y.master = j[j.length - 1];
    y.tpls = j
}, applySubTemplate:function (g, a, c, e, f) {
    var d = this, b = d.tpls[g];
    return b.compiled.call(d, a, c, e, f)
}, codeRe:/\{\[((?:\\\]|.|\n)*?)\]\}/g, re:/\{([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\/]\s?[\d\.\+\-\*\/\(\)]+)?\}/g, compileTpl:function (tpl) {
    var fm = Ext.util.Format, me = this, useFormat = me.disableFormats !== true, body, bodyReturn, evaluatedFn;

    function fn(m, name, format, args, math) {
        var v;
        if (name.substr(0, 4) == "xtpl") {
            return"',this.applySubTemplate(" + name.substr(4) + ", values, parent, xindex, xcount),'"
        }
        if (name == ".") {
            v = 'typeof values == "string" ? values : ""'
        } else {
            if (name == "#") {
                v = "xindex"
            } else {
                if (name.substr(0, 7) == "parent.") {
                    v = name
                } else {
                    if (name.indexOf(".") != -1) {
                        v = "values." + name
                    } else {
                        v = "values['" + name + "']"
                    }
                }
            }
        }
        if (math) {
            v = "(" + v + math + ")"
        }
        if (format && useFormat) {
            args = args ? "," + args : "";
            if (format.substr(0, 5) != "this.") {
                format = "fm." + format + "("
            } else {
                format = "this." + format.substr(5) + "("
            }
        } else {
            args = "";
            format = "(" + v + " === undefined ? '' : "
        }
        return"'," + format + v + args + "),'"
    }

    function codeFn(m, code) {
        return"',(" + code.replace(me.compileARe, "'") + "),'"
    }

    bodyReturn = tpl.body.replace(me.compileBRe, "\\n").replace(me.compileCRe, "\\'").replace(me.re, fn).replace(me.codeRe, codeFn);
    body = "evaluatedFn = function(values, parent, xindex, xcount){return ['" + bodyReturn + "'].join('');};";
    eval(body);
    tpl.compiled = function (values, parent, xindex, xcount) {
        var vs, length, buffer, i;
        if (tpl.test && !tpl.test.call(me, values, parent, xindex, xcount)) {
            return""
        }
        vs = tpl.target ? tpl.target.call(me, values, parent) : values;
        if (!vs) {
            return""
        }
        parent = tpl.target ? values : parent;
        if (tpl.target && Ext.isArray(vs)) {
            buffer = [], length = vs.length;
            if (tpl.exec) {
                for (i = 0; i < length; i++) {
                    buffer[buffer.length] = evaluatedFn.call(me, vs[i], parent, i + 1, length);
                    tpl.exec.call(me, vs[i], parent, i + 1, length)
                }
            } else {
                for (i = 0; i < length; i++) {
                    buffer[buffer.length] = evaluatedFn.call(me, vs[i], parent, i + 1, length)
                }
            }
            return buffer.join("")
        }
        if (tpl.exec) {
            tpl.exec.call(me, vs, parent, xindex, xcount)
        }
        return evaluatedFn.call(me, vs, parent, xindex, xcount)
    };
    return this
}, applyTemplate:function (a) {
    return this.master.compiled.call(this, a, {}, 1, 1)
}, compile:function () {
    return this
}});
Ext.XTemplate.prototype.apply = Ext.XTemplate.prototype.applyTemplate;
Ext.XTemplate.from = function (b, a) {
    b = Ext.getDom(b);
    return new Ext.XTemplate(b.value || b.innerHTML, a || {})
};
Ext.util.Sorter = Ext.extend(Object, {direction:"ASC", constructor:function (a) {
    Ext.apply(this, a);
    if (this.property == undefined && this.sorterFn == undefined) {
        throw"A Sorter requires either a property or a sorter function"
    }
    this.sort = this.createSortFunction(this.sorterFn || this.defaultSorterFn)
}, createSortFunction:function (b) {
    var c = this, d = c.property, e = c.direction, a = e.toUpperCase() == "DESC" ? -1 : 1;
    return function (g, f) {
        return a * b.call(c, g, f)
    }
}, defaultSorterFn:function (b, a) {
    var d = this.getRoot(b)[this.property], c = this.getRoot(a)[this.property];
    return d > c ? 1 : (d < c ? -1 : 0)
}, getRoot:function (a) {
    return this.root == undefined ? a : a[this.root]
}});
Ext.util.Filter = Ext.extend(Object, {anyMatch:false, exactMatch:false, caseSensitive:false, constructor:function (a) {
    Ext.apply(this, a);
    this.filter = this.filter || this.filterFn;
    if (this.filter == undefined) {
        if (this.property == undefined || this.value == undefined) {
        } else {
            this.filter = this.createFilterFn()
        }
        this.filterFn = this.filter
    }
}, createFilterFn:function () {
    var a = this, c = a.createValueMatcher(), b = a.property;
    return function (d) {
        return c.test(a.getRoot.call(a, d)[b])
    }
}, getRoot:function (a) {
    return this.root == undefined ? a : a[this.root]
}, createValueMatcher:function () {
    var d = this, e = d.value, f = d.anyMatch, c = d.exactMatch, a = d.caseSensitive, b = Ext.util.Format.escapeRegex;
    if (!e.exec) {
        e = String(e);
        if (f === true) {
            e = b(e)
        } else {
            e = "^" + b(e);
            if (c === true) {
                e += "$"
            }
        }
        e = new RegExp(e, a ? "" : "i")
    }
    return e
}});
Ext.util.Functions = {createInterceptor:function (d, c, b, a) {
    var e = d;
    if (!Ext.isFunction(c)) {
        return d
    } else {
        return function () {
            var g = this, f = arguments;
            c.target = g;
            c.method = d;
            return(c.apply(b || g || window, f) !== false) ? d.apply(g || window, f) : a || null
        }
    }
}, createDelegate:function (c, d, b, a) {
    if (!Ext.isFunction(c)) {
        return c
    }
    return function () {
        var f = b || arguments;
        if (a === true) {
            f = Array.prototype.slice.call(arguments, 0);
            f = f.concat(b)
        } else {
            if (Ext.isNumber(a)) {
                f = Array.prototype.slice.call(arguments, 0);
                var e = [a, 0].concat(b);
                Array.prototype.splice.apply(f, e)
            }
        }
        return c.apply(d || window, f)
    }
}, defer:function (d, c, e, b, a) {
    d = Ext.util.Functions.createDelegate(d, e, b, a);
    if (c > 0) {
        return setTimeout(d, c)
    }
    d();
    return 0
}, createSequence:function (c, b, a) {
    if (!Ext.isFunction(b)) {
        return c
    } else {
        return function () {
            var d = c.apply(this || window, arguments);
            b.apply(a || this || window, arguments);
            return d
        }
    }
}};
Ext.defer = Ext.util.Functions.defer;
Ext.createInterceptor = Ext.util.Functions.createInterceptor;
Ext.createSequence = Ext.util.Functions.createSequence;
Ext.createDelegate = Ext.util.Functions.createDelegate;
Ext.util.Date = {getElapsed:function (b, a) {
    return Math.abs(b - (a || new Date))
}};
Ext.util.Numbers = {toFixedBroken:(0.9).toFixed() != 1, constrain:function (c, b, a) {
    c = parseFloat(c);
    if (!isNaN(b)) {
        c = Math.max(c, b)
    }
    if (!isNaN(a)) {
        c = Math.min(c, a)
    }
    return c
}, toFixed:function (c, a) {
    if (Ext.util.Numbers.toFixedBroken) {
        a = a || 0;
        var b = Math.pow(10, a);
        return Math.round(c * b) / b
    }
    return c.toFixed(a)
}};
Ext.util.Format = {defaultDateFormat:"m/d/Y", escapeRe:/('|\\)/g, trimRe:/^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g, formatRe:/\{(\d+)\}/g, escapeRegexRe:/([-.*+?^${}()|[\]\/\\])/g, ellipsis:function (c, a, d) {
    if (c && c.length > a) {
        if (d) {
            var e = c.substr(0, a - 2), b = Math.max(e.lastIndexOf(" "), e.lastIndexOf("."), e.lastIndexOf("!"), e.lastIndexOf("?"));
            if (b != -1 && b >= (a - 15)) {
                return e.substr(0, b) + "..."
            }
        }
        return c.substr(0, a - 3) + "..."
    }
    return c
}, escapeRegex:function (a) {
    return a.replace(Ext.util.Format.escapeRegexRe, "\\$1")
}, escape:function (a) {
    return a.replace(Ext.util.Format.escapeRe, "\\$1")
}, toggle:function (b, c, a) {
    return b == c ? a : c
}, trim:function (a) {
    return a.replace(Ext.util.Format.trimRe, "")
}, leftPad:function (d, b, c) {
    var a = String(d);
    c = c || " ";
    while (a.length < b) {
        a = c + a
    }
    return a
}, format:function (b) {
    var a = Ext.toArray(arguments, 1);
    return b.replace(Ext.util.Format.formatRe, function (c, d) {
        return a[d]
    })
}, htmlEncode:function (a) {
    return !a ? a : String(a).replace(/&/g, "&amp;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;")
}, htmlDecode:function (a) {
    return !a ? a : String(a).replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&quot;/g, '"').replace(/&amp;/g, "&")
}, date:function (a, b) {
    if (!a) {
        return""
    }
    if (!Ext.isDate(a)) {
        a = new Date(Date.parse(a))
    }
    return a.dateFormat(b || Ext.util.Format.defaultDateFormat)
}};
Ext.LoadMask = Ext.extend(Ext.util.Observable, {msg:"Loading...", msgCls:"x-mask-loading", disabled:false, constructor:function (b, a) {
    this.el = Ext.get(b);
    Ext.apply(this, a);
    this.addEvents("show", "hide");
    if (this.store) {
        this.bindStore(this.store, true)
    }
    Ext.LoadMask.superclass.constructor.call(this)
}, bindStore:function (a, b) {
    if (!b && this.store) {
        this.mun(this.store, {scope:this, beforeload:this.onBeforeLoad, load:this.onLoad, exception:this.onLoad});
        if (!a) {
            this.store = null
        }
    }
    if (a) {
        a = Ext.StoreMgr.lookup(a);
        this.mon(a, {scope:this, beforeload:this.onBeforeLoad, load:this.onLoad, exception:this.onLoad})
    }
    this.store = a;
    if (a && a.isLoading()) {
        this.onBeforeLoad()
    }
}, disable:function () {
    this.disabled = true
}, enable:function () {
    this.disabled = false
}, isDisabled:function () {
    return this.disabled
}, onLoad:function () {
    this.el.unmask();
    this.fireEvent("hide", this, this.el, this.store)
}, onBeforeLoad:function () {
    if (!this.disabled) {
        this.el.mask(Ext.LoadingSpinner + '<div class="x-loading-msg">' + this.msg + "</div>", this.msgCls, false);
        this.fireEvent("show", this, this.el, this.store)
    }
}, show:function () {
    this.onBeforeLoad()
}, hide:function () {
    this.onLoad()
}, destroy:function () {
    this.hide();
    this.clearListeners()
}});
Ext.LoadingSpinner = '<div class="x-loading-spinner"><span class="x-loading-top"></span><span class="x-loading-right"></span><span class="x-loading-bottom"></span><span class="x-loading-left"></span></div>';
Ext.applyIf(Array.prototype, {indexOf:function (b, c) {
    var a = this.length;
    c = c || 0;
    c += (c < 0) ? a : 0;
    for (; c < a; ++c) {
        if (this[c] === b) {
            return c
        }
    }
    return -1
}, remove:function (b) {
    var a = this.indexOf(b);
    if (a != -1) {
        this.splice(a, 1)
    }
    return this
}, contains:function (a) {
    return this.indexOf(a) !== -1
}});
Ext.ComponentMgr = new Ext.AbstractManager({typeName:"xtype", create:function (b, d) {
    if (b.isComponent) {
        return b
    } else {
        var c = b.xtype || d, a = this.types[c];
        if (!a) {
            throw"Attempting to create a component with an xtype that has not been registered: " + c
        }
        return new a(b)
    }
    return b.render ? b : new (b)
}, registerType:function (b, a) {
    this.types[b] = a;
    a[this.typeName] = b;
    a.prototype[this.typeName] = b
}});
Ext.reg = function () {
    return Ext.ComponentMgr.registerType.apply(Ext.ComponentMgr, arguments)
};
Ext.create = function () {
    return Ext.ComponentMgr.create.apply(Ext.ComponentMgr, arguments)
};
Ext.ComponentQuery = new function () {
    var g = this, j = ["var r = [],", "i = 0,", "it = arguments[0],", "l = it.length,", "c;", "for (; i < l; i++) {", "c = it[i].{0};", "if (c) {", "r.push(c);", "}", "}", "return r;"].join(""), e = function (o, n) {
        return n.method.apply(this, [o].concat(n.args))
    }, a = function (p, u) {
        var n = [], q, t = p.length, s, o = u != ">";
        for (q = 0; q < t; q++) {
            s = p[q];
            if (s.getRefItems) {
                n = n.concat(s.getRefItems(o))
            }
        }
        return n
    }, f = function (o) {
        var n = [], p, s = o.length, q;
        for (p = 0; p < s; p++) {
            q = o[p];
            while (!!(q = q.ownerCt)) {
                n.push(q)
            }
        }
        return n
    }, l = function (o, u, t) {
        if (u == "*") {
            return o.slice()
        } else {
            var n = [], p, s = o.length, q;
            for (p = 0; p < s; p++) {
                q = o[p];
                if (q.isXType(u, t)) {
                    n.push(q)
                }
            }
            return n
        }
    }, i = function (o, s) {
        var n = [], p, t = o.length, q;
        for (p = 0; p < t; p++) {
            q = o[p];
            if (q.el ? q.el.hasCls(s) : q.initCls().contains(s)) {
                n.push(q)
            }
        }
        return n
    }, m = function (p, v, o, u) {
        var n = [], q, t = p.length, s;
        for (q = 0; q < t; q++) {
            s = p[q];
            if ((u === undefined) ? !!s[v] : (s[v] == u)) {
                n.push(s)
            }
        }
        return n
    }, d = function (o, t) {
        var n = [], p, s = o.length, q;
        for (p = 0; p < s; p++) {
            q = o[p];
            if (q.getItemId() == t) {
                n.push(q)
            }
        }
        return n
    }, k = function (n, o, p) {
        return g.pseudos[o](n, p)
    }, h = /^(\s?([>\^])\s?|\s|$)/, c = /^(?:(#)?([\w-]+|\*)(?:\((true|false)\))?)|(?:\{([^\}]+)\})/, b = [
        {re:/^\.([\w-]+)(?:\((true|false)\))?/, method:l},
        {re:/^(?:[\[\{](?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/, method:m},
        {re:/^#([\w-]+)/, method:d},
        {re:/^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/, method:k}
    ];
    g.Query = Ext.extend(Object, {constructor:function (n) {
        n = n || {};
        Ext.apply(this, n)
    }, execute:function (o) {
        var q = this.operations, t = q.length, p, s, n;
        if (!o) {
            n = Ext.ComponentMgr.all.getArray()
        }
        for (s = 0; s < t; s++) {
            p = q[s];
            if (p.mode == "^") {
                n = f(n || [o])
            } else {
                if (p.mode) {
                    n = a(n || [o], p.mode)
                } else {
                    n = e(n || a([o]), p)
                }
            }
            if (s == t - 1) {
                return n
            }
        }
        return[]
    }, is:function (p) {
        var o = this.operations, s = o.length, q, n = Ext.isArray(p) ? p : [p];
        for (q = 0; q < s && n.length; q++) {
            n = e(n, o[q])
        }
        return n.length != 0
    }});
    Ext.apply(this, {cache:{}, pseudos:{}, query:function (n, w) {
        var x = n.split(","), q = x.length, o, t, p = [], y = [], v = {}, s, u;
        for (o = 0; o < q; o++) {
            n = Ext.util.Format.trim(x[o]);
            t = this.cache[n];
            if (!t) {
                this.cache[n] = t = this.parse(n)
            }
            p = p.concat(t.execute(w))
        }
        if (q > 1) {
            s = p.length;
            for (o = 0; o < s; o++) {
                u = p[o];
                if (!v[u.id]) {
                    y.push(u);
                    v[u.id] = true
                }
            }
            p = y
        }
        return p
    }, is:function (o, n) {
        if (!n) {
            return true
        }
        var p = this.cache[n];
        if (!p) {
            this.cache[n] = p = this.parse(n)
        }
        return p.is(o)
    }, parse:function (o) {
        var n = [], u = b.length, v, p, w, x, y, t, q, s;
        while (o && v != o) {
            v = o;
            p = o.match(c);
            if (p) {
                w = p[1];
                if (w == "#") {
                    n.push({method:d, args:[Ext.util.Format.trim(p[2])]})
                } else {
                    if (w == ".") {
                        n.push({method:i, args:[Ext.util.Format.trim(p[2])]})
                    } else {
                        if (p[4]) {
                            n.push({method:new Function(Ext.util.Format.format(j, p[4])), args:[]})
                        } else {
                            n.push({method:l, args:[Ext.util.Format.trim(p[2]), Boolean(p[3])]})
                        }
                    }
                }
                o = o.replace(p[0], "")
            }
            while (!(x = o.match(h))) {
                for (q = 0; o && q < u; q++) {
                    s = b[q];
                    y = o.match(s.re);
                    if (y) {
                        n.push({method:s.method, args:y.splice(1)});
                        o = o.replace(y[0], "");
                        break
                    }
                    if (q == (u - 1)) {
                        throw'Invalid ComponentQuery selector: "' + arguments[0] + '"'
                    }
                }
            }
            if (x[1]) {
                n.push({mode:x[2] || x[1]});
                o = o.replace(x[0], "")
            }
        }
        return new g.Query({operations:n})
    }})
};
Ext.PluginMgr = new Ext.AbstractManager({typeName:"ptype", create:function (b, c) {
    var a = this.types[b.ptype || c];
    if (a.init) {
        return a
    } else {
        return new a(b)
    }
}, findByType:function (c, f) {
    var e = [], b = this.types;
    for (var a in b) {
        if (!b.hasOwnProperty(a)) {
            continue
        }
        var d = b[a];
        if (d.type == c && (!f || (f === true && d.isDefault))) {
            e.push(d)
        }
    }
    return e
}});
Ext.preg = function () {
    return Ext.PluginMgr.registerType.apply(Ext.PluginMgr, arguments)
};
Ext.EventManager = {optionsRe:/^(?:capture|scope|delay|buffer|single|stopEvent|disableLocking|preventDefault|stopPropagation|normalized|args|delegate|horizontal|vertical|dragThreshold|holdThreshold|doubleTapThreshold|cancelThreshold|singleTapThreshold|fireClickEvent)$/, touchRe:/^(?:pinch|pinchstart|pinchend|tap|singletap|doubletap|swipe|swipeleft|swiperight|drag|dragstart|dragend|touchdown|touchstart|touchmove|touchend|taphold|tapstart|tapcancel)$/i, addListener:function (b, a, e, d, g) {
    if (Ext.isObject(a)) {
        this.handleListenerConfig(b, a);
        return
    }
    var f = Ext.getDom(b);
    if (!f) {
        throw'Error listening for "' + a + '". Element "' + b + "\" doesn't exist."
    }
    if (!e) {
        throw'Error listening for "' + a + '". No handler function specified'
    }
    var h = this.touchRe.test(a);
    var c = this.createListenerWrap(f, a, e, d, g, h);
    this.getEventListenerCache(f, a).push({fn:e, wrap:c, scope:d});
    if (h) {
        Ext.gesture.Manager.addEventListener(f, a, c, g)
    } else {
        g = g || {};
        f.addEventListener(a, c, g.capture || false)
    }
}, removeListener:function (g, k, l, m) {
    if (Ext.isObject(k)) {
        this.handleListenerConfig(g, k, true);
        return
    }
    var e = Ext.getDom(g), a = this.getEventListenerCache(e, k), h = a.length, f, c, b, d;
    while (h--) {
        c = a[h];
        if (c && (!l || c.fn == l) && (!m || c.scope === m)) {
            b = c.wrap;
            if (b.task) {
                clearTimeout(b.task);
                delete b.task
            }
            f = b.tasks && b.tasks.length;
            if (f) {
                while (f--) {
                    clearTimeout(b.tasks[f])
                }
                delete b.tasks
            }
            if (this.touchRe.test(k)) {
                Ext.gesture.Manager.removeEventListener(e, k, b)
            } else {
                e.removeEventListener(k, b, false)
            }
            a.splice(h, 1)
        }
    }
}, removeAll:function (b) {
    var d = Ext.getDom(b), a = this.getElementEventCache(d), c;
    for (c in a) {
        if (!a.hasOwnProperty(c)) {
            continue
        }
        this.removeListener(d, c)
    }
    Ext.cache[d.id].events = {}
}, purgeElement:function (d, e, b) {
    var f = Ext.getDom(d), c = 0, a;
    if (b) {
        this.removeListener(f, b)
    } else {
        this.removeAll(f)
    }
    if (e && f && f.childNodes) {
        for (a = d.childNodes.length; c < a; c++) {
            this.purgeElement(d.childNodes[c], e, b)
        }
    }
}, handleListenerConfig:function (d, b, a) {
    var c, e;
    for (c in b) {
        if (!b.hasOwnProperty(c)) {
            continue
        }
        if (!this.optionsRe.test(c)) {
            e = b[c];
            if (Ext.isFunction(e)) {
                this[(a ? "remove" : "add") + "Listener"](d, c, e, b.scope, b)
            } else {
                this[(a ? "remove" : "add") + "Listener"](d, c, b.fn, b.scope, b)
            }
        }
    }
}, getId:function (a) {
    var b = false, c;
    a = Ext.getDom(a);
    if (a === document || a === window) {
        b = true
    }
    c = Ext.id(a);
    if (!Ext.cache[c]) {
        Ext.Element.addToCache(new Ext.Element(a), c);
        if (b) {
            Ext.cache[c].skipGarbageCollection = true
        }
    }
    return c
}, createListenerWrap:function (h, a, c, b, g, i) {
    g = !Ext.isObject(g) ? {} : g;
    var d = ["if(!window.Ext) {return;}"];
    if (i) {
        d.push("e = new Ext.TouchEventObjectImpl(e, args);")
    } else {
        if (g.buffer || g.delay) {
            d.push("e = new Ext.EventObjectImpl(e);")
        } else {
            d.push("e = Ext.EventObject.setEvent(e);")
        }
    }
    if (g.delegate) {
        d.push('var t = e.getTarget("' + g.delegate + '", this);');
        d.push("if(!t) {return;}")
    } else {
        d.push("var t = e.target;")
    }
    if (g.target) {
        d.push("if(e.target !== o.target) {return;}")
    }
    if (g.stopEvent) {
        d.push("e.stopEvent();")
    } else {
        if (g.preventDefault) {
            d.push("e.preventDefault();")
        }
        if (g.stopPropagation) {
            d.push("e.stopPropagation();")
        }
    }
    if (g.normalized === false) {
        d.push("e = e.browserEvent;")
    }
    if (g.buffer) {
        d.push("(wrap.task && clearTimeout(wrap.task));");
        d.push("wrap.task = setTimeout(function(){")
    }
    if (g.delay) {
        d.push("wrap.tasks = wrap.tasks || [];");
        d.push("wrap.tasks.push(setTimeout(function(){")
    }
    d.push("fn.call(scope || dom, e, t, o);");
    if (g.single) {
        d.push("Ext.EventManager.removeListener(dom, ename, fn, scope);")
    }
    if (g.delay) {
        d.push("}, " + g.delay + "));")
    }
    if (g.buffer) {
        d.push("}, " + g.buffer + ");")
    }
    var e = new Function("e", "o", "fn", "scope", "ename", "dom", "wrap", "args", d.join("\n"));
    return function (j, f) {
        e.call(h, j, g, c, b, a, h, arguments.callee, f)
    }
}, getEventListenerCache:function (c, a) {
    var b = this.getElementEventCache(c);
    return b[a] || (b[a] = [])
}, getElementEventCache:function (b) {
    var a = Ext.cache[this.getId(b)];
    return a.events || (a.events = {})
}, onDocumentReady:function (d, c, b) {
    var f = this, g = f.readyEvent, e;
    if (Ext.isReady) {
        g || (g = new Ext.util.Event());
        g.addListener(d, c, b);
        g.fire();
        g.listeners = []
    } else {
        if (!g) {
            g = f.readyEvent = new Ext.util.Event();
            var a = function () {
                Ext.isReady = true;
                window.removeEventListener("load", arguments.callee, false);
                if (e) {
                    clearInterval(e)
                }
                setTimeout(function () {
                    Ext.supports.init();
                    Ext.gesture.Manager.init();
                    Ext.orientation = Ext.Element.getOrientation();
                    g.fire({orientation:Ext.orientation, width:Ext.Element.getViewportWidth(), height:Ext.Element.getViewportHeight()});
                    g.listeners = []
                }, 50)
            };
            e = setInterval(function () {
                if (/loaded|complete/.test(document.readyState)) {
                    clearInterval(e);
                    e = null;
                    a()
                }
            }, 10);
            window.addEventListener("load", a, false)
        }
        b = b || {};
        b.delay = b.delay || 1;
        g.addListener(d, c, b)
    }
}, onWindowResize:function (c, b, a) {
    var e = this, f = e.resizeEvent;
    if (!f) {
        e.resizeEvent = f = new Ext.util.Event();
        var d = function () {
            f.fire(Ext.Element.getViewportWidth(), Ext.Element.getViewportHeight())
        };
        this.addListener(window, "resize", d, this)
    }
    f.addListener(c, b, a)
}, onOrientationChange:function (c, b, a) {
    var e = this, d = e.orientationEvent;
    if (!d) {
        e.orientationEvent = d = new Ext.util.Event();
        var f = function (g, h) {
            Ext.orientation = Ext.Viewport.getOrientation();
            d.fire(Ext.orientation, h.width, h.height)
        };
        Ext.Viewport.on("resize", f, this)
    }
    d.addListener(c, b, a)
}, unOrientationChange:function (c, b, a) {
    var e = this, d = e.orientationEvent;
    if (d) {
        d.removeListener(c, b, a)
    }
}};
Ext.EventManager.on = Ext.EventManager.addListener;
Ext.EventManager.un = Ext.EventManager.removeListener;
Ext.onReady = Ext.EventManager.onDocumentReady;
Ext.EventObjectImpl = Ext.extend(Object, {constructor:function (a) {
    if (a) {
        this.setEvent(a.browserEvent || a)
    }
}, setEvent:function (c) {
    var b = this;
    if (c == b || (c && c.browserEvent)) {
        return c
    }
    b.browserEvent = c;
    if (c) {
        b.type = c.type;
        var a = c.target;
        b.target = a && a.nodeType == 3 ? a.parentNode : a;
        b.xy = [c.pageX, c.pageY];
        b.timestamp = c.timeStamp
    } else {
        b.target = null;
        b.xy = [0, 0]
    }
    return b
}, stopEvent:function () {
    this.stopPropagation();
    this.preventDefault()
}, preventDefault:function () {
    if (this.browserEvent) {
        this.browserEvent.preventDefault()
    }
}, stopPropagation:function () {
    if (this.browserEvent) {
        this.browserEvent.stopPropagation()
    }
}, getPageX:function () {
    return this.xy[0]
}, getPageY:function () {
    return this.xy[1]
}, getXY:function () {
    return this.xy
}, getTarget:function (b, c, a) {
    return b ? Ext.fly(this.target).findParent(b, c, a) : (a ? Ext.get(this.target) : this.target)
}, getTime:function () {
    return this.timestamp
}});
Ext.EventObject = new Ext.EventObjectImpl();
Ext.is = {init:function (b) {
    var f = this, c = f.platforms, e = c.length, d, a;
    b = b || window.navigator;
    for (d = 0; d < e; d++) {
        a = c[d];
        f[a.identity] = a.regex.test(b[a.property])
    }
    f.Desktop = f.Mac || f.Windows || (f.Linux && !f.Android);
    f.iOS = f.iPhone || f.iPad || f.iPod;
    f.Standalone = !!b.standalone;
    d = f.Android && (/Android\s(\d+\.\d+)/.exec(b.userAgent));
    if (d) {
        f.AndroidVersion = d[1];
        f.AndroidMajorVersion = parseInt(d[1], 10)
    }
    f.Tablet = f.iPad || (f.Android && f.AndroidMajorVersion === 3);
    f.Phone = !f.Desktop && !f.Tablet;
    f.MultiTouch = !f.Blackberry && !f.Desktop && !(f.Android && f.AndroidVersion < 3)
}, platforms:[
    {property:"platform", regex:/iPhone/i, identity:"iPhone"},
    {property:"platform", regex:/iPod/i, identity:"iPod"},
    {property:"userAgent", regex:/iPad/i, identity:"iPad"},
    {property:"userAgent", regex:/Blackberry/i, identity:"Blackberry"},
    {property:"userAgent", regex:/Android/i, identity:"Android"},
    {property:"platform", regex:/Mac/i, identity:"Mac"},
    {property:"platform", regex:/Win/i, identity:"Windows"},
    {property:"platform", regex:/Linux/i, identity:"Linux"}
]};
Ext.is.init();
Ext.supports = {init:function () {
    var d = document, f = d.createElement("div"), b = this.tests, c = b.length, a, e;
    f.innerHTML = ['<div style="height:30px;width:50px;">', '<div style="height:20px;width:20px;"></div>', "</div>", '<div style="float:left; background-color:transparent;"></div>'].join("");
    d.body.appendChild(f);
    for (a = 0; a < c; a++) {
        e = b[a];
        this[e.identity] = e.fn.call(this, d, f)
    }
    d.body.removeChild(f)
}, OrientationChange:((typeof window.orientation != "undefined") && ("onorientationchange" in window)), DeviceMotion:("ondevicemotion" in window), Touch:("ontouchstart" in window) && (!Ext.is.Desktop), tests:[
    {identity:"Transitions", fn:function (f, h) {
        var e = ["webkit", "Moz", "o", "ms", "khtml"], g = "TransitionEnd", a = [e[0] + g, "transitionend", e[2] + g, e[3] + g, e[4] + g], d = e.length, c = 0, b = false;
        h = Ext.get(h);
        for (; c < d; c++) {
            if (h.getStyle(e[c] + "TransitionProperty")) {
                Ext.supports.CSS3Prefix = e[c];
                Ext.supports.CSS3TransitionEnd = a[c];
                b = true;
                break
            }
        }
        return b
    }},
    {identity:"RightMargin", fn:function (b, c, a) {
        a = b.defaultView;
        return !(a && a.getComputedStyle(c.firstChild.firstChild, null).marginRight != "0px")
    }},
    {identity:"TransparentColor", fn:function (b, c, a) {
        a = b.defaultView;
        return !(a && a.getComputedStyle(c.lastChild, null).backgroundColor != "transparent")
    }},
    {identity:"SVG", fn:function (a) {
        return !!a.createElementNS && !!a.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect
    }},
    {identity:"Canvas", fn:function (a) {
        return !!a.createElement("canvas").getContext
    }},
    {identity:"VML", fn:function (a) {
        var b = a.createElement("div");
        b.innerHTML = "<!--[if vml]><br><br><![endif]-->";
        return(b.childNodes.length == 2)
    }},
    {identity:"Float", fn:function (a, b) {
        return !!b.lastChild.style.cssFloat
    }},
    {identity:"AudioTag", fn:function (a) {
        return !!a.createElement("audio").canPlayType
    }},
    {identity:"History", fn:function () {
        return !!(window.history && history.pushState)
    }},
    {identity:"CSS3DTransform", fn:function () {
        return(typeof WebKitCSSMatrix != "undefined" && new WebKitCSSMatrix().hasOwnProperty("m41"))
    }},
    {identity:"CSS3LinearGradient", fn:function (e, g) {
        var d = "background-image:", b = "-webkit-gradient(linear, left top, right bottom, from(black), to(white))", f = "linear-gradient(left top, black, white)", c = "-moz-" + f, a = [d + b, d + f, d + c];
        g.style.cssText = a.join(";");
        return("" + g.style.backgroundImage).indexOf("gradient") !== -1
    }},
    {identity:"CSS3BorderRadius", fn:function (d, e) {
        var b = ["borderRadius", "BorderRadius", "MozBorderRadius", "WebkitBorderRadius", "OBorderRadius", "KhtmlBorderRadius"], c = false, a;
        for (a = 0; a < b.length; a++) {
            if (document.body.style[b[a]] !== undefined) {
                return c = true
            }
        }
        return c
    }},
    {identity:"GeoLocation", fn:function () {
        return(typeof navigator != "undefined" && typeof navigator.geolocation != "undefined") || (typeof google != "undefined" && typeof google.gears != "undefined")
    }}
]};
Ext.data.Batch = Ext.extend(Ext.util.Observable, {autoStart:false, current:-1, total:0, isRunning:false, isComplete:false, hasException:false, pauseOnException:true, constructor:function (a) {
    this.addEvents("complete", "exception", "operationcomplete", "operation-complete");
    Ext.data.Batch.superclass.constructor.call(this, a);
    this.operations = []
}, add:function (a) {
    this.total++;
    a.setBatch(this);
    this.operations.push(a)
}, start:function () {
    this.hasException = false;
    this.isRunning = true;
    this.runNextOperation()
}, runNextOperation:function () {
    this.runOperation(this.current + 1)
}, pause:function () {
    this.isRunning = false
}, runOperation:function (d) {
    var c = this.operations, b = c[d];
    if (b == undefined) {
        this.isRunning = false;
        this.isComplete = true;
        this.fireEvent("complete", this, c[c.length - 1])
    } else {
        this.current = d;
        var a = function (e) {
            var f = e.hasException();
            if (f) {
                this.hasException = true;
                this.fireEvent("exception", this, e)
            } else {
                this.fireEvent("operation-complete", this, e);
                this.fireEvent("operationcomplete", this, e)
            }
            if (f && this.pauseOnException) {
                this.pause()
            } else {
                e.setCompleted();
                this.runNextOperation()
            }
        };
        b.setStarted();
        this.proxy[b.action](b, a, this)
    }
}});
Ext.data.Model = Ext.extend(Ext.util.Stateful, {evented:false, isModel:true, phantom:false, idProperty:"id", constructor:function (e, g) {
    e = e || {};
    this.internalId = (g || g === 0) ? g : Ext.data.Model.id(this);
    Ext.data.Model.superclass.constructor.apply(this);
    var a = this.fields.items, d = a.length, f, b, c;
    for (c = 0; c < d; c++) {
        f = a[c];
        b = f.name;
        if (e[b] == undefined) {
            e[b] = f.defaultValue
        }
    }
    this.set(e);
    this.dirty = false;
    if (this.getId()) {
        this.phantom = false
    }
    if (typeof this.init == "function") {
        this.init()
    }
}, validate:function () {
    var j = new Ext.data.Errors(), c = this.validations, e = Ext.data.validations, b, d, h, a, g, f;
    if (c) {
        b = c.length;
        for (f = 0; f < b; f++) {
            d = c[f];
            h = d.field || d.name;
            g = d.type;
            a = e[g](d, this.get(h));
            if (!a) {
                j.add({field:h, message:d.message || e[g + "Message"]})
            }
        }
    }
    return j
}, getProxy:function () {
    return this.constructor.proxy
}, save:function (j) {
    var f = this, a = f.phantom ? "create" : "update";
    j = j || {};
    Ext.apply(j, {records:[f], action:a});
    var b = new Ext.data.Operation(j), h = j.success, d = j.failure, e = j.callback, i = j.scope, c;
    var g = function (k) {
        c = k.getRecords()[0];
        if (k.wasSuccessful()) {
            f.set(c.data);
            c.dirty = false;
            if (typeof h == "function") {
                h.call(i, c, k)
            }
        } else {
            if (typeof d == "function") {
                d.call(i, c, k)
            }
        }
        if (typeof e == "function") {
            e.call(i, c, k)
        }
    };
    f.getProxy()[a](b, g, f);
    return f
}, getId:function () {
    return this.get(this.idProperty)
}, setId:function (a) {
    this.set(this.idProperty, a)
}, join:function (a) {
    this.store = a
}, unjoin:function (a) {
    delete this.store
}, afterEdit:function () {
    this.callStore("afterEdit")
}, afterReject:function () {
    this.callStore("afterReject")
}, afterCommit:function () {
    this.callStore("afterCommit")
}, callStore:function (b) {
    var a = this.store;
    if (a != undefined && typeof a[b] == "function") {
        a[b](this)
    }
}});
Ext.apply(Ext.data.Model, {setProxy:function (a) {
    a = Ext.data.ProxyMgr.create(a);
    a.setModel(this);
    this.proxy = a;
    return a
}, load:function (a, b) {
    b = Ext.applyIf(b || {}, {action:"read", id:a});
    var c = new Ext.data.Operation(b), f = b.callback, h = b.success, e = b.failure, i = b.scope, d, g;
    g = function (j) {
        d = j.getRecords()[0];
        if (j.wasSuccessful()) {
            if (typeof h == "function") {
                h.call(i, d, j)
            }
        } else {
            if (typeof e == "function") {
                e.call(i, d, j)
            }
        }
        if (typeof f == "function") {
            f.call(i, d, j)
        }
    };
    this.proxy.read(c, g, this)
}});
Ext.data.Model.id = function (a) {
    a.phantom = true;
    return[Ext.data.Model.PREFIX, "-", Ext.data.Model.AUTO_ID++].join("")
};
Ext.ns("Ext.data.Record");
Ext.data.Record.id = Ext.data.Model.id;
Ext.data.Model.PREFIX = "ext-record";
Ext.data.Model.AUTO_ID = 1;
Ext.data.Model.EDIT = "edit";
Ext.data.Model.REJECT = "reject";
Ext.data.Model.COMMIT = "commit";
Ext.data.Association = Ext.extend(Object, {primaryKey:"id", constructor:function (b) {
    Ext.apply(this, b);
    var c = Ext.ModelMgr.types, d = b.ownerModel, f = b.associatedModel, e = c[d], g = c[f], a;
    if (e == undefined) {
        throw new Error("The configured ownerModel was not valid (you tried " + d + ")")
    }
    if (g == undefined) {
        throw new Error("The configured associatedModel was not valid (you tried " + f + ")")
    }
    this.ownerModel = e;
    this.associatedModel = g;
    Ext.applyIf(this, {ownerName:d, associatedName:f})
}});
Ext.data.HasManyAssociation = Ext.extend(Ext.data.Association, {constructor:function (c) {
    Ext.data.HasManyAssociation.superclass.constructor.apply(this, arguments);
    var a = this.ownerModel.prototype, b = this.name;
    Ext.applyIf(this, {storeName:b + "Store", foreignKey:this.ownerName.toLowerCase() + "_id"});
    a[b] = this.createStore()
}, createStore:function () {
    var f = this.associatedModel, b = this.storeName, c = this.foreignKey, a = this.primaryKey, e = this.filterProperty, d = this.storeConfig || {};
    return function () {
        var j = this, h, i, g = {};
        if (j[b] == undefined) {
            if (e) {
                i = {property:e, value:j.get(e), exactMatch:true}
            } else {
                i = {property:c, value:j.get(a), exactMatch:true}
            }
            g[c] = j.get(a);
            h = Ext.apply({}, d, {model:f, filters:[i], remoteFilter:false, modelDefaults:g});
            j[b] = new Ext.data.Store(h)
        }
        return j[b]
    }
}});
Ext.data.BelongsToAssociation = Ext.extend(Ext.data.Association, {constructor:function (c) {
    Ext.data.BelongsToAssociation.superclass.constructor.apply(this, arguments);
    var e = this, a = e.ownerModel.prototype, f = e.associatedName, d = e.getterName || "get" + f, b = e.setterName || "set" + f;
    Ext.applyIf(e, {name:f, foreignKey:f.toLowerCase() + "_id", instanceName:f + "BelongsToInstance"});
    a[d] = e.createGetter();
    a[b] = e.createSetter()
}, createSetter:function () {
    var c = this, d = c.ownerModel, e = c.associatedModel, b = c.foreignKey, a = c.primaryKey;
    return function (h, f, g) {
        this.set(b, h);
        if (typeof f == "function") {
            f = {callback:f, scope:g || this}
        }
        if (Ext.isObject(f)) {
            return this.save(f)
        }
    }
}, createGetter:function () {
    var d = this, f = d.ownerModel, e = d.associatedName, g = d.associatedModel, c = d.foreignKey, b = d.primaryKey, a = d.instanceName;
    return function (j, k) {
        j = j || {};
        var l = this.get(c), h, i;
        if (this[a] == undefined) {
            h = Ext.ModelMgr.create({}, e);
            h.set(b, l);
            if (typeof j == "function") {
                j = {callback:j, scope:k || this}
            }
            g.load(l, j)
        } else {
            h = this[a];
            if (typeof j == "function") {
                j.call(k || this, h)
            }
            if (j.success) {
                j.success.call(k || this, h)
            }
            if (j.callback) {
                j.callback.call(k || this, h)
            }
            return h
        }
    }
}});
Ext.data.PolymorphicAssociation = Ext.extend(Ext.data.Association, {constructor:function (c) {
    Ext.data.PolymorphicAssociation.superclass.constructor.call(this, c);
    var a = this.ownerModel.prototype, b = this.name;
    Ext.applyIf(this, {associationIdField:this.ownerName.toLowerCase() + "_id"});
    a[b] = this.createStore()
}, createStore:function () {
    var b = this, f = this.ownerName, d = this.name + "Store", g = this.associatedModel, c = this.primaryKey, a = "associated_id", e = "associated_model";
    return function () {
        var k = this, h = {}, i, j;
        if (k[d] == undefined) {
            j = [
                {property:a, value:k.get(c), exactMatch:true},
                {property:e, value:f, exactMatch:true}
            ];
            h[a] = k.get(c);
            h[e] = f;
            i = Ext.apply({}, b.storeConfig || {}, {model:g, filters:j, remoteFilter:false, modelDefaults:h});
            k[d] = new Ext.data.Store(i)
        }
        return k[d]
    }
}});
Ext.data.validations = {presenceMessage:"must be present", lengthMessage:"is the wrong length", formatMessage:"is the wrong format", inclusionMessage:"is not included in the list of acceptable values", exclusionMessage:"is not an acceptable value", presence:function (a, b) {
    if (b == undefined) {
        b = a
    }
    return !!b
}, length:function (b, e) {
    if (e == undefined) {
        return false
    }
    var d = e.length, c = b.min, a = b.max;
    if ((c && d < c) || (a && d > a)) {
        return false
    } else {
        return true
    }
}, format:function (a, b) {
    return !!(a.matcher && a.matcher.test(b))
}, inclusion:function (a, b) {
    return a.list && a.list.indexOf(b) != -1
}, exclusion:function (a, b) {
    return a.list && a.list.indexOf(b) == -1
}};
Ext.data.Errors = Ext.extend(Ext.util.MixedCollection, {isValid:function () {
    return this.length == 0
}, getByField:function (e) {
    var d = [], a, c, b;
    for (b = 0; b < this.length; b++) {
        a = this.items[b];
        if (a.field == e) {
            d.push(a)
        }
    }
    return d
}});
Ext.data.Field = Ext.extend(Object, {constructor:function (b) {
    if (Ext.isString(b)) {
        b = {name:b}
    }
    Ext.apply(this, b);
    var d = Ext.data.Types, a = this.sortType, c;
    if (this.type) {
        if (Ext.isString(this.type)) {
            this.type = d[this.type.toUpperCase()] || d.AUTO
        }
    } else {
        this.type = d.AUTO
    }
    if (Ext.isString(a)) {
        this.sortType = Ext.data.SortTypes[a]
    } else {
        if (Ext.isEmpty(a)) {
            this.sortType = this.type.sortType
        }
    }
    if (!this.convert) {
        this.convert = this.type.convert
    }
}, dateFormat:null, useNull:false, defaultValue:"", mapping:null, sortType:null, sortDir:"ASC", allowBlank:true});
Ext.data.SortTypes = {none:function (a) {
    return a
}, stripTagsRE:/<\/?[^>]+>/gi, asText:function (a) {
    return String(a).replace(this.stripTagsRE, "")
}, asUCText:function (a) {
    return String(a).toUpperCase().replace(this.stripTagsRE, "")
}, asUCString:function (a) {
    return String(a).toUpperCase()
}, asDate:function (a) {
    if (!a) {
        return 0
    }
    if (Ext.isDate(a)) {
        return a.getTime()
    }
    return Date.parse(String(a))
}, asFloat:function (a) {
    var b = parseFloat(String(a).replace(/,/g, ""));
    return isNaN(b) ? 0 : b
}, asInt:function (a) {
    var b = parseInt(String(a).replace(/,/g, ""), 10);
    return isNaN(b) ? 0 : b
}};
Ext.data.Types = new function () {
    var a = Ext.data.SortTypes;
    Ext.apply(this, {stripRe:/[\$,%]/g, AUTO:{convert:function (b) {
        return b
    }, sortType:a.none, type:"auto"}, STRING:{convert:function (b) {
        return(b === undefined || b === null) ? "" : String(b)
    }, sortType:a.asUCString, type:"string"}, INT:{convert:function (b) {
        return b !== undefined && b !== null && b !== "" ? parseInt(String(b).replace(Ext.data.Types.stripRe, ""), 10) : (this.useNull ? null : 0)
    }, sortType:a.none, type:"int"}, FLOAT:{convert:function (b) {
        return b !== undefined && b !== null && b !== "" ? parseFloat(String(b).replace(Ext.data.Types.stripRe, ""), 10) : (this.useNull ? null : 0)
    }, sortType:a.none, type:"float"}, BOOL:{convert:function (b) {
        return b === true || b === "true" || b == 1
    }, sortType:a.none, type:"bool"}, DATE:{convert:function (c) {
        var d = this.dateFormat;
        if (!c) {
            return null
        }
        if (Ext.isDate(c)) {
            return c
        }
        if (d) {
            if (d == "timestamp") {
                return new Date(c * 1000)
            }
            if (d == "time") {
                return new Date(parseInt(c, 10))
            }
            return Date.parseDate(c, d)
        }
        var b = Date.parse(c);
        return b ? new Date(b) : null
    }, sortType:a.asDate, type:"date"}});
    Ext.apply(this, {BOOLEAN:this.BOOL, INTEGER:this.INT, NUMBER:this.FLOAT})
};
Ext.ModelMgr = new Ext.AbstractManager({typeName:"mtype", defaultProxyType:"ajax", associationStack:[], registerType:function (t, s) {
    var e = Ext.PluginMgr, l = e.findByType("model", true), k = s.fields || [], p = s.associations || [], o = s.belongsTo, h = s.hasMany, q = s.extend, j = s.plugins || [], b, c, d, n, f, a, g, m;
    if (o) {
        if (!Ext.isArray(o)) {
            o = [o]
        }
        for (n = 0; n < o.length; n++) {
            b = o[n];
            if (!Ext.isObject(b)) {
                b = {model:b}
            }
            Ext.apply(b, {type:"belongsTo"});
            p.push(b)
        }
        delete s.belongsTo
    }
    if (h) {
        if (!Ext.isArray(h)) {
            h = [h]
        }
        for (n = 0; n < h.length; n++) {
            b = h[n];
            if (!Ext.isObject(b)) {
                b = {model:b}
            }
            Ext.apply(b, {type:"hasMany"});
            p.push(b)
        }
        delete s.hasMany
    }
    if (q) {
        f = this.types[q];
        a = f.prototype;
        g = a.validations;
        m = f.proxy;
        k = a.fields.items.concat(k);
        p = a.associations.items.concat(p);
        s.validations = g ? g.concat(s.validations) : s.validations
    } else {
        f = Ext.data.Model;
        m = s.proxy
    }
    c = Ext.extend(f, s);
    for (n = 0, d = j.length; n < d; n++) {
        l.push(e.create(j[n]))
    }
    this.types[t] = c;
    Ext.override(c, {plugins:l, fields:this.createFields(k), associations:this.createAssociations(p, t)});
    c.modelName = t;
    Ext.data.Model.setProxy.call(c, m || this.defaultProxyType);
    c.getProxy = c.prototype.getProxy;
    c.load = function () {
        Ext.data.Model.load.apply(this, arguments)
    };
    for (n = 0, d = l.length; n < d; n++) {
        l[n].bootstrap(c, s)
    }
    c.defined = true;
    this.onModelDefined(c);
    return c
}, onModelDefined:function (c) {
    var a = this.associationStack, f = a.length, e = [], b, d;
    for (d = 0; d < f; d++) {
        b = a[d];
        if (b.associatedModel == c.modelName) {
            e.push(b)
        }
    }
    f = e.length;
    for (d = 0; d < f; d++) {
        this.addAssociation(e[d], this.types[e[d].ownerModel].prototype.associations);
        a.remove(e[d])
    }
}, createAssociations:function (e, b) {
    var f = e.length, d, c, a;
    c = new Ext.util.MixedCollection(false, function (g) {
        return g.name
    });
    for (d = 0; d < f; d++) {
        a = e[d];
        Ext.apply(a, {ownerModel:b, associatedModel:a.model});
        if (this.types[a.model] == undefined) {
            this.associationStack.push(a)
        } else {
            this.addAssociation(a, c)
        }
    }
    return c
}, addAssociation:function (a, b) {
    var c = a.type;
    if (c == "belongsTo") {
        b.add(new Ext.data.BelongsToAssociation(a))
    }
    if (c == "hasMany") {
        b.add(new Ext.data.HasManyAssociation(a))
    }
    if (c == "polymorphic") {
        b.add(new Ext.data.PolymorphicAssociation(a))
    }
}, createFields:function (a) {
    var d = a.length, c, b;
    b = new Ext.util.MixedCollection(false, function (e) {
        return e.name
    });
    for (c = 0; c < d; c++) {
        b.add(new Ext.data.Field(a[c]))
    }
    return b
}, getModel:function (b) {
    var a = b;
    if (typeof a == "string") {
        a = this.types[a]
    }
    return a
}, create:function (c, b, d) {
    var a = typeof b == "function" ? b : this.types[b || c.name];
    return new a(c, d)
}});
Ext.regModel = function () {
    return Ext.ModelMgr.registerType.apply(Ext.ModelMgr, arguments)
};
Ext.data.Operation = Ext.extend(Object, {synchronous:true, action:undefined, filters:undefined, sorters:undefined, group:undefined, start:undefined, limit:undefined, batch:undefined, started:false, running:false, complete:false, success:undefined, exception:false, error:undefined, constructor:function (a) {
    Ext.apply(this, a || {})
}, setStarted:function () {
    this.started = true;
    this.running = true
}, setCompleted:function () {
    this.complete = true;
    this.running = false
}, setSuccessful:function () {
    this.success = true
}, setException:function (a) {
    this.exception = true;
    this.success = false;
    this.running = false;
    this.error = a
}, markStarted:function () {
    console.warn("Operation: markStarted has been deprecated. Please use setStarted");
    return this.setStarted()
}, markCompleted:function () {
    console.warn("Operation: markCompleted has been deprecated. Please use setCompleted");
    return this.setCompleted()
}, markSuccessful:function () {
    console.warn("Operation: markSuccessful has been deprecated. Please use setSuccessful");
    return this.setSuccessful()
}, markException:function () {
    console.warn("Operation: markException has been deprecated. Please use setException");
    return this.setException()
}, hasException:function () {
    return this.exception === true
}, getError:function () {
    return this.error
}, getRecords:function () {
    var a = this.getResultSet();
    return(a == undefined ? this.records : a.records)
}, getResultSet:function () {
    return this.resultSet
}, isStarted:function () {
    return this.started === true
}, isRunning:function () {
    return this.running === true
}, isComplete:function () {
    return this.complete === true
}, wasSuccessful:function () {
    return this.isComplete() && this.success === true
}, setBatch:function (a) {
    this.batch = a
}, allowWrite:function () {
    return this.action != "read"
}});
Ext.data.ProxyMgr = new Ext.AbstractManager({create:function (a) {
    if (a == undefined || typeof a == "string") {
        a = {type:a}
    }
    if (!(a instanceof Ext.data.Proxy)) {
        Ext.applyIf(a, {type:this.defaultProxyType, model:this.model});
        var b = a[this.typeName] || a.type, c = this.types[b];
        if (c == undefined) {
            throw new Error(Ext.util.Format.format("The '{0}' type has not been registered with this manager", b))
        }
        return new c(a)
    } else {
        return a
    }
}});
Ext.data.ReaderMgr = new Ext.AbstractManager({typeName:"rtype"});
Ext.data.Request = Ext.extend(Object, {action:undefined, params:undefined, method:"GET", url:undefined, constructor:function (a) {
    Ext.apply(this, a)
}});
Ext.data.ResultSet = Ext.extend(Object, {loaded:true, count:0, total:0, success:false, constructor:function (a) {
    Ext.apply(this, a);
    this.totalRecords = this.total;
    if (a.count == undefined) {
        this.count = this.records.length
    }
}});
Ext.data.AbstractStore = Ext.extend(Ext.util.Observable, {remoteSort:false, remoteFilter:false, autoLoad:false, autoSave:false, batchUpdateMode:"operation", filterOnLoad:true, sortOnLoad:true, defaultSortDirection:"ASC", implicitModel:false, defaultProxyType:"memory", isDestroyed:false, isStore:true, constructor:function (a) {
    this.addEvents("add", "remove", "update", "datachanged", "beforeload", "load", "beforesync");
    Ext.apply(this, a);
    this.removed = [];
    this.sortToggle = {};
    Ext.data.AbstractStore.superclass.constructor.apply(this, arguments);
    this.model = Ext.ModelMgr.getModel(a.model);
    Ext.applyIf(this, {modelDefaults:{}});
    if (!this.model && a.fields) {
        this.model = Ext.regModel("ImplicitModel-" + this.storeId || Ext.id(), {fields:a.fields});
        delete this.fields;
        this.implicitModel = true
    }
    this.setProxy(a.proxy || this.model.proxy);
    if (this.id && !this.storeId) {
        this.storeId = this.id;
        delete this.id
    }
    if (this.storeId) {
        Ext.StoreMgr.register(this)
    }
    this.sorters = new Ext.util.MixedCollection();
    this.sorters.addAll(this.decodeSorters(a.sorters));
    this.filters = new Ext.util.MixedCollection();
    this.filters.addAll(this.decodeFilters(a.filters))
}, setProxy:function (a) {
    if (a instanceof Ext.data.Proxy) {
        a.setModel(this.model)
    } else {
        Ext.applyIf(a, {model:this.model});
        a = Ext.data.ProxyMgr.create(a)
    }
    this.proxy = a;
    return this.proxy
}, getProxy:function () {
    return this.proxy
}, create:function (d, c) {
    var a = Ext.ModelMgr.create(Ext.applyIf(d, this.modelDefaults), this.model.modelName), b;
    c = c || {};
    Ext.applyIf(c, {action:"create", records:[a]});
    b = new Ext.data.Operation(c);
    this.proxy.create(b, this.onProxyWrite, this);
    return a
}, read:function () {
    return this.load.apply(this, arguments)
}, onProxyRead:Ext.emptyFn, update:function (b) {
    b = b || {};
    Ext.applyIf(b, {action:"update", records:this.getUpdatedRecords()});
    var a = new Ext.data.Operation(b);
    return this.proxy.update(a, this.onProxyWrite, this)
}, onProxyWrite:Ext.emptyFn, destroy:function (b) {
    b = b || {};
    Ext.applyIf(b, {action:"destroy", records:this.getRemovedRecords()});
    var a = new Ext.data.Operation(b);
    return this.proxy.destroy(a, this.onProxyWrite, this)
}, onBatchOperationComplete:function (b, a) {
    return this.onProxyWrite(a)
}, onBatchComplete:function (c, a) {
    var b = c.operations, e = b.length, d;
    this.suspendEvents();
    for (d = 0; d < e; d++) {
        this.onProxyWrite(b[d])
    }
    this.resumeEvents();
    this.fireEvent("datachanged", this)
}, onBatchException:function (b, a) {
}, filterNew:function (a) {
    return a.phantom == true || a.needsAdd == true
}, getNewRecords:function () {
    return[]
}, getUpdatedRecords:function () {
    return[]
}, filterDirty:function (a) {
    return a.dirty == true
}, getRemovedRecords:function () {
    return this.removed
}, sort:function (b, a) {
}, decodeSorters:function (d) {
    if (!Ext.isArray(d)) {
        if (d == undefined) {
            d = []
        } else {
            d = [d]
        }
    }
    var c = d.length, e = Ext.util.Sorter, a, b;
    for (b = 0; b < c; b++) {
        a = d[b];
        if (!(a instanceof e)) {
            if (Ext.isString(a)) {
                a = {property:a}
            }
            Ext.applyIf(a, {root:"data", direction:"ASC"});
            if (a.fn) {
                a.sorterFn = a.fn
            }
            if (typeof a == "function") {
                a = {sorterFn:a}
            }
            d[b] = new e(a)
        }
    }
    return d
}, filter:function (a, b) {
}, createSortFunction:function (d, c) {
    c = c || "ASC";
    var b = c.toUpperCase() == "DESC" ? -1 : 1;
    var a = this.model.prototype.fields, e = a.get(d).sortType;
    return function (g, f) {
        var i = e(g.data[d]), h = e(f.data[d]);
        return b * (i > h ? 1 : (i < h ? -1 : 0))
    }
}, decodeFilters:function (e) {
    if (!Ext.isArray(e)) {
        if (e == undefined) {
            e = []
        } else {
            e = [e]
        }
    }
    var d = e.length, a = Ext.util.Filter, b, c;
    for (c = 0; c < d; c++) {
        b = e[c];
        if (!(b instanceof a)) {
            Ext.apply(b, {root:"data"});
            if (b.fn) {
                b.filterFn = b.fn
            }
            if (typeof b == "function") {
                b = {filterFn:b}
            }
            e[c] = new a(b)
        }
    }
    return e
}, clearFilter:function (a) {
}, isFiltered:function () {
}, filterBy:function (b, a) {
}, sync:function () {
    var d = this, b = {}, e = d.getNewRecords(), c = d.getUpdatedRecords(), a = d.getRemovedRecords(), f = false;
    if (e.length > 0) {
        b.create = e;
        f = true
    }
    if (c.length > 0) {
        b.update = c;
        f = true
    }
    if (a.length > 0) {
        b.destroy = a;
        f = true
    }
    if (f && d.fireEvent("beforesync", b) !== false) {
        d.proxy.batch(b, d.getBatchListeners())
    }
}, getBatchListeners:function () {
    var a = {scope:this, exception:this.onBatchException};
    if (this.batchUpdateMode == "operation") {
        a.operationcomplete = this.onBatchOperationComplete
    } else {
        a.complete = this.onBatchComplete
    }
    return a
}, save:function () {
    return this.sync.apply(this, arguments)
}, load:function (b) {
    var c = this, a;
    b = b || {};
    Ext.applyIf(b, {action:"read", filters:c.filters.items, sorters:c.sorters.items});
    a = new Ext.data.Operation(b);
    if (c.fireEvent("beforeload", c, a) !== false) {
        c.loading = true;
        c.proxy.read(a, c.onProxyLoad, c)
    }
    return c
}, afterEdit:function (a) {
    this.fireEvent("update", this, a, Ext.data.Model.EDIT)
}, afterReject:function (a) {
    this.fireEvent("update", this, a, Ext.data.Model.REJECT)
}, afterCommit:function (a) {
    if (this.autoSave) {
        this.sync()
    }
    this.fireEvent("update", this, a, Ext.data.Model.COMMIT)
}, clearData:Ext.emptyFn, destroyStore:function () {
    if (!this.isDestroyed) {
        if (this.storeId) {
            Ext.StoreMgr.unregister(this)
        }
        this.clearData();
        this.data = null;
        this.tree = null;
        this.reader = this.writer = null;
        this.clearListeners();
        this.isDestroyed = true;
        if (this.implicitModel) {
            Ext.destroy(this.model)
        }
    }
}, getSortState:function () {
    return this.sortInfo
}, getCount:function () {
}, getById:function (a) {
}, removeAll:function () {
}});
Ext.data.Store = Ext.extend(Ext.data.AbstractStore, {remoteSort:false, remoteFilter:false, groupField:undefined, groupDir:"ASC", pageSize:25, currentPage:1, clearOnPageLoad:true, implicitModel:false, loading:false, sortOnFilter:true, isStore:true, constructor:function (a) {
    a = a || {};
    this.data = new Ext.util.MixedCollection(false, function (d) {
        return d.internalId
    });
    if (a.data) {
        this.inlineData = a.data;
        delete a.data
    }
    Ext.data.Store.superclass.constructor.call(this, a);
    var b = this.proxy, c = this.inlineData;
    if (c) {
        if (b instanceof Ext.data.MemoryProxy) {
            b.data = c;
            this.read()
        } else {
            this.add.apply(this, c)
        }
        this.sort();
        delete this.inlineData
    } else {
        if (this.autoLoad) {
            Ext.defer(this.load, 10, this, [typeof this.autoLoad == "object" ? this.autoLoad : undefined])
        }
    }
}, getGroups:function () {
    var d = this.data.items, f = d.length, a = [], c = {}, b, g, h, e;
    for (e = 0; e < f; e++) {
        b = d[e];
        g = this.getGroupString(b);
        h = c[g];
        if (h == undefined) {
            h = {name:g, children:[]};
            a.push(h);
            c[g] = h
        }
        h.children.push(b)
    }
    return a
}, getGroupString:function (a) {
    return a.get(this.groupField)
}, first:function () {
    return this.data.first()
}, last:function () {
    return this.data.last()
}, insert:function (d, c) {
    var e, b, a;
    c = [].concat(c);
    for (e = 0, a = c.length; e < a; e++) {
        b = this.createModel(c[e]);
        b.set(this.modelDefaults);
        this.data.insert(d + e, b);
        b.join(this)
    }
    if (this.snapshot) {
        this.snapshot.addAll(c)
    }
    this.fireEvent("add", this, c, d);
    this.fireEvent("datachanged", this)
}, add:function (b) {
    if (!Ext.isArray(b)) {
        b = Array.prototype.slice.apply(arguments)
    }
    var d = b.length, a, c;
    for (c = 0; c < d; c++) {
        a = this.createModel(b[c]);
        if (a.phantom == false) {
            a.needsAdd = true
        }
        b[c] = a
    }
    this.insert(this.data.length, b);
    return b
}, createModel:function (a) {
    if (!(a instanceof Ext.data.Model)) {
        a = Ext.ModelMgr.create(a, this.model)
    }
    return a
}, each:function (b, a) {
    this.data.each(b, a)
}, remove:function (b) {
    if (!Ext.isArray(b)) {
        b = [b]
    }
    var e = b.length, d, c, a;
    for (d = 0; d < e; d++) {
        a = b[d];
        c = this.data.indexOf(a);
        if (c > -1) {
            this.removed.push(a);
            if (this.snapshot) {
                this.snapshot.remove(a)
            }
            a.unjoin(this);
            this.data.remove(a);
            this.fireEvent("remove", this, a, c)
        }
    }
    this.fireEvent("datachanged", this)
}, removeAt:function (b) {
    var a = this.getAt(b);
    if (a) {
        this.remove(a)
    }
}, load:function (a) {
    a = a || {};
    if (Ext.isFunction(a)) {
        a = {callback:a}
    }
    Ext.applyIf(a, {group:{field:this.groupField, direction:this.groupDir}, start:0, limit:this.pageSize, addRecords:false});
    return Ext.data.Store.superclass.load.call(this, a)
}, isLoading:function () {
    return this.loading
}, onProxyLoad:function (b) {
    var a = b.getRecords();
    this.loadRecords(a, b.addRecords);
    this.loading = false;
    this.fireEvent("load", this, a, b.wasSuccessful());
    this.fireEvent("read", this, a, b.wasSuccessful());
    var c = b.callback;
    if (typeof c == "function") {
        c.call(b.scope || this, a, b, b.wasSuccessful())
    }
}, onProxyWrite:function (c) {
    var g = this.data, f = c.action, b = c.getRecords(), e = b.length, h = c.callback, a, d;
    if (c.wasSuccessful()) {
        if (f == "create" || f == "update") {
            for (d = 0; d < e; d++) {
                a = b[d];
                a.phantom = false;
                a.join(this);
                g.replace(a)
            }
        } else {
            if (f == "destroy") {
                for (d = 0; d < e; d++) {
                    a = b[d];
                    a.unjoin(this);
                    g.remove(a)
                }
                this.removed = []
            }
        }
        this.fireEvent("datachanged")
    }
    if (typeof h == "function") {
        h.call(c.scope || this, b, c, c.wasSuccessful())
    }
}, getNewRecords:function () {
    return this.data.filterBy(this.filterNew).items
}, getUpdatedRecords:function () {
    return this.data.filterBy(this.filterDirty).items
}, sort:function (e, d) {
    if (Ext.isString(e)) {
        var c = e, b = this.sortToggle, a = Ext.util.Format.toggle;
        if (d == undefined) {
            b[c] = a(b[c] || "", "ASC", "DESC");
            d = b[c]
        }
        e = {property:c, direction:d}
    }
    if (arguments.length != 0) {
        this.sorters.clear()
    }
    this.sorters.addAll(this.decodeSorters(e));
    if (this.remoteSort) {
        this.load()
    } else {
        this.data.sort(this.sorters.items);
        this.fireEvent("datachanged", this)
    }
}, filter:function (a, b) {
    if (Ext.isString(a)) {
        a = {property:a, value:b}
    }
    this.filters.addAll(this.decodeFilters(a));
    if (this.remoteFilter) {
        this.load()
    } else {
        this.snapshot = this.snapshot || this.data.clone();
        this.data = this.data.filter(this.filters.items);
        if (this.sortOnFilter && !this.remoteSort) {
            this.sort()
        } else {
            this.fireEvent("datachanged", this)
        }
    }
}, clearFilter:function (a) {
    this.filters.clear();
    if (this.isFiltered()) {
        this.data = this.snapshot.clone();
        delete this.snapshot;
        if (a !== true) {
            this.fireEvent("datachanged", this)
        }
    }
}, isFiltered:function () {
    return !!this.snapshot && this.snapshot != this.data
}, filterBy:function (b, a) {
    this.snapshot = this.snapshot || this.data.clone();
    this.data = this.queryBy(b, a || this);
    this.fireEvent("datachanged", this)
}, queryBy:function (b, a) {
    var c = this.snapshot || this.data;
    return c.filterBy(b, a || this)
}, loadData:function (f, a) {
    var c = this.model, e = f.length, d, b;
    for (d = 0; d < e; d++) {
        b = f[d];
        if (!(b instanceof Ext.data.Model)) {
            f[d] = Ext.ModelMgr.create(b, c)
        }
    }
    this.loadRecords(f, a)
}, loadRecords:function (a, d) {
    if (!d) {
        this.data.clear()
    }
    this.data.addAll(a);
    for (var b = 0, c = a.length; b < c; b++) {
        a[b].needsAdd = false;
        a[b].join(this)
    }
    this.suspendEvents();
    if (this.filterOnLoad && !this.remoteFilter) {
        this.filter()
    }
    if (this.sortOnLoad && !this.remoteSort) {
        this.sort()
    }
    this.resumeEvents();
    this.fireEvent("datachanged", this, a)
}, loadPage:function (a) {
    this.currentPage = a;
    this.read({page:a, start:(a - 1) * this.pageSize, limit:this.pageSize, addRecords:!this.clearOnPageLoad})
}, nextPage:function () {
    this.loadPage(this.currentPage + 1)
}, previousPage:function () {
    this.loadPage(this.currentPage - 1)
}, clearData:function () {
    this.data.each(function (a) {
        a.unjoin()
    });
    this.data.clear()
}, find:function (e, d, g, f, a, c) {
    var b = this.createFilterFn(e, d, f, a, c);
    return b ? this.data.findIndexBy(b, null, g) : -1
}, findRecord:function () {
    var a = this.find.apply(this, arguments);
    return a != -1 ? this.getAt(a) : null
}, createFilterFn:function (d, c, e, a, b) {
    if (Ext.isEmpty(c)) {
        return false
    }
    c = this.data.createValueMatcher(c, e, a, b);
    return function (f) {
        return c.test(f.data[d])
    }
}, findExact:function (b, a, c) {
    return this.data.findIndexBy(function (d) {
        return d.get(b) === a
    }, this, c)
}, findBy:function (b, a, c) {
    return this.data.findIndexBy(b, a, c)
}, collect:function (f, g, a) {
    var k = [], h = {}, b, j, e, d, c;
    if (a === true && this.snapshot) {
        d = this.snapshot.items
    } else {
        d = this.data.items
    }
    b = d.length;
    for (c = 0; c < b; c++) {
        j = d[c].data[f];
        e = String(j);
        if ((g || !Ext.isEmpty(j)) && !h[e]) {
            h[e] = true;
            k[k.length] = j
        }
    }
    return k
}, sum:function (e, f, a) {
    var b = this.data.items, d = 0, c;
    f = f || 0;
    a = (a || a === 0) ? a : b.length - 1;
    for (c = f; c <= a; c++) {
        d += (b[c].data[e] || 0)
    }
    return d
}, getCount:function () {
    return this.data.length || 0
}, getAt:function (a) {
    return this.data.getAt(a)
}, getRange:function (b, a) {
    return this.data.getRange(b, a)
}, getById:function (a) {
    return(this.snapshot || this.data).findBy(function (b) {
        return b.getId() === a
    })
}, indexOf:function (a) {
    return this.data.indexOf(a)
}, indexOfId:function (a) {
    return this.data.indexOfKey(a)
}, removeAll:function (b) {
    var a = [];
    this.each(function (c) {
        a.push(c)
    });
    this.clearData();
    if (this.snapshot) {
        this.snapshot.clear()
    }
    if (b !== true) {
        this.fireEvent("clear", this, a)
    }
}});
Ext.data.TreeStore = Ext.extend(Ext.data.AbstractStore, {clearOnLoad:true, nodeParam:"node", defaultRootId:"root", constructor:function (c) {
    c = c || {};
    var a = c.root || {};
    a.id = a.id || this.defaultRootId;
    var b = new Ext.data.RecordNode(a);
    this.tree = new Ext.data.Tree(b);
    this.tree.treeStore = this;
    Ext.data.TreeStore.superclass.constructor.call(this, c);
    if (c.root) {
        this.read({node:b, doPreload:true})
    }
}, getRootNode:function () {
    return this.tree.getRootNode()
}, getNodeById:function (a) {
    return this.tree.getNodeById(a)
}, load:function (e) {
    e = e || {};
    e.params = e.params || {};
    var f = e.node || this.tree.getRootNode(), d, c, a = this.proxy.reader, b;
    if (this.clearOnLoad) {
        while (f.firstChild) {
            f.removeChild(f.firstChild)
        }
    }
    if (!e.doPreload) {
        Ext.applyIf(e, {node:f});
        c = f.getRecord();
        e.params[this.nodeParam] = c ? c.getId() : "root";
        return Ext.data.TreeStore.superclass.load.call(this, e)
    } else {
        b = a.getRoot(f.isRoot ? f.attributes : f.getRecord().raw);
        d = a.extractData(b, true);
        this.fillNode(f, d);
        return true
    }
}, fillNode:function (g, c) {
    g.loaded = true;
    var f = c.length, a, e = 0, d, b = g.subStore;
    for (; e < f; e++) {
        d = c[e].raw;
        c[e].data.leaf = d.leaf;
        a = new Ext.data.RecordNode({id:c[e].getId(), leaf:d.leaf, record:c[e], expanded:d.expanded});
        g.appendChild(a);
        if (c[e].doPreload) {
            this.load({node:a, doPreload:true})
        }
    }
    if (b) {
        if (this.clearOnLoad) {
            b.removeAll()
        }
        b.add.apply(b, c)
    }
}, onProxyLoad:function (b) {
    var a = b.getRecords();
    this.fillNode(b.node, a);
    this.fireEvent("read", this, b.node, a, b.wasSuccessful());
    var c = b.callback;
    if (typeof c == "function") {
        c.call(b.scope || this, a, b, b.wasSuccessful())
    }
}, getSubStore:function (a) {
    if (a && a.node) {
        a = a.node
    }
    return a.getSubStore()
}, removeAll:function () {
    var a = this.getRootNode();
    a.destroy()
}});
Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), {register:function () {
    for (var a = 0, b; (b = arguments[a]); a++) {
        this.add(b)
    }
}, unregister:function () {
    for (var a = 0, b; (b = arguments[a]); a++) {
        this.remove(this.lookup(b))
    }
}, lookup:function (e) {
    if (Ext.isArray(e)) {
        var b = ["field1"], d = !Ext.isArray(e[0]);
        if (!d) {
            for (var c = 2, a = e[0].length; c <= a; ++c) {
                b.push("field" + c)
            }
        }
        return new Ext.data.ArrayStore({data:e, fields:b, expandData:d, autoDestroy:true, autoCreated:true})
    }
    return Ext.isObject(e) ? (e.events ? e : Ext.create(e, "store")) : this.get(e)
}, getKey:function (a) {
    return a.storeId
}});
Ext.regStore = function (c, b) {
    var a;
    if (Ext.isObject(c)) {
        b = c
    } else {
        b.storeId = c
    }
    if (b instanceof Ext.data.Store) {
        a = b
    } else {
        a = new Ext.data.Store(b)
    }
    return Ext.StoreMgr.register(a)
};
Ext.getStore = function (a) {
    return Ext.StoreMgr.lookup(a)
};
Ext.data.WriterMgr = new Ext.AbstractManager({});
Ext.data.Tree = Ext.extend(Ext.util.Observable, {constructor:function (a) {
    this.nodeHash = {};
    this.root = null;
    if (a) {
        this.setRootNode(a)
    }
    this.addEvents("append", "remove", "move", "insert", "beforeappend", "beforeremove", "beforemove", "beforeinsert");
    Ext.data.Tree.superclass.constructor.call(this)
}, pathSeparator:"/", proxyNodeEvent:function () {
    return this.fireEvent.apply(this, arguments)
}, getRootNode:function () {
    return this.root
}, setRootNode:function (a) {
    this.root = a;
    a.ownerTree = this;
    a.isRoot = true;
    this.registerNode(a);
    return a
}, getNodeById:function (a) {
    return this.nodeHash[a]
}, registerNode:function (a) {
    this.nodeHash[a.id] = a
}, unregisterNode:function (a) {
    delete this.nodeHash[a.id]
}, toString:function () {
    return"[Tree" + (this.id ? " " + this.id : "") + "]"
}});
Ext.data.Node = Ext.extend(Ext.util.Observable, {constructor:function (a) {
    this.attributes = a || {};
    this.leaf = !!this.attributes.leaf;
    this.id = this.attributes.id;
    if (!this.id) {
        this.id = Ext.id(null, "xnode-");
        this.attributes.id = this.id
    }
    this.childNodes = [];
    this.parentNode = null;
    this.firstChild = null;
    this.lastChild = null;
    this.previousSibling = null;
    this.nextSibling = null;
    this.addEvents({append:true, remove:true, move:true, insert:true, beforeappend:true, beforeremove:true, beforemove:true, beforeinsert:true});
    this.listeners = this.attributes.listeners;
    Ext.data.Node.superclass.constructor.call(this)
}, fireEvent:function (b) {
    if (Ext.data.Node.superclass.fireEvent.apply(this, arguments) === false) {
        return false
    }
    var a = this.getOwnerTree();
    if (a) {
        if (a.proxyNodeEvent.apply(a, arguments) === false) {
            return false
        }
    }
    return true
}, isLeaf:function () {
    return this.leaf === true
}, setFirstChild:function (a) {
    this.firstChild = a
}, setLastChild:function (a) {
    this.lastChild = a
}, isLast:function () {
    return(!this.parentNode ? true : this.parentNode.lastChild == this)
}, isFirst:function () {
    return(!this.parentNode ? true : this.parentNode.firstChild == this)
}, hasChildNodes:function () {
    return !this.isLeaf() && this.childNodes.length > 0
}, isExpandable:function () {
    return this.attributes.expandable || this.hasChildNodes()
}, appendChild:function (e) {
    var f = false, d, a;
    if (Ext.isArray(e)) {
        f = e
    } else {
        if (arguments.length > 1) {
            f = arguments
        }
    }
    if (f) {
        a = f.length;
        for (d = 0; d < a; d++) {
            this.appendChild(f[d])
        }
    } else {
        if (this.fireEvent("beforeappend", this.ownerTree, this, e) === false) {
            return false
        }
        var b = this.childNodes.length;
        var c = e.parentNode;
        if (c) {
            if (e.fireEvent("beforemove", e.getOwnerTree(), e, c, this, b) === false) {
                return false
            }
            c.removeChild(e)
        }
        b = this.childNodes.length;
        if (b === 0) {
            this.setFirstChild(e)
        }
        this.childNodes.push(e);
        e.parentNode = this;
        var g = this.childNodes[b - 1];
        if (g) {
            e.previousSibling = g;
            g.nextSibling = e
        } else {
            e.previousSibling = null
        }
        e.nextSibling = null;
        this.setLastChild(e);
        e.setOwnerTree(this.getOwnerTree());
        this.fireEvent("append", this.ownerTree, this, e, b);
        if (c) {
            e.fireEvent("move", this.ownerTree, e, c, this, b)
        }
        return e
    }
}, removeChild:function (c, b) {
    var a = this.indexOf(c);
    if (a == -1) {
        return false
    }
    if (this.fireEvent("beforeremove", this.ownerTree, this, c) === false) {
        return false
    }
    this.childNodes.splice(a, 1);
    if (c.previousSibling) {
        c.previousSibling.nextSibling = c.nextSibling
    }
    if (c.nextSibling) {
        c.nextSibling.previousSibling = c.previousSibling
    }
    if (this.firstChild == c) {
        this.setFirstChild(c.nextSibling)
    }
    if (this.lastChild == c) {
        this.setLastChild(c.previousSibling)
    }
    this.fireEvent("remove", this.ownerTree, this, c);
    if (b) {
        c.destroy(true)
    } else {
        c.clear()
    }
    return c
}, clear:function (a) {
    this.setOwnerTree(null, a);
    this.parentNode = this.previousSibling = this.nextSibling = null;
    if (a) {
        this.firstChild = this.lastChild = null
    }
}, destroy:function (a) {
    if (a === true) {
        this.clearListeners();
        this.clear(true);
        Ext.each(this.childNodes, function (b) {
            b.destroy(true)
        });
        this.childNodes = null
    } else {
        this.remove(true)
    }
}, insertBefore:function (d, a) {
    if (!a) {
        return this.appendChild(d)
    }
    if (d == a) {
        return false
    }
    if (this.fireEvent("beforeinsert", this.ownerTree, this, d, a) === false) {
        return false
    }
    var b = this.indexOf(a), c = d.parentNode, e = b;
    if (c == this && this.indexOf(d) < b) {
        e--
    }
    if (c) {
        if (d.fireEvent("beforemove", d.getOwnerTree(), d, c, this, b, a) === false) {
            return false
        }
        c.removeChild(d)
    }
    if (e === 0) {
        this.setFirstChild(d)
    }
    this.childNodes.splice(e, 0, d);
    d.parentNode = this;
    var f = this.childNodes[e - 1];
    if (f) {
        d.previousSibling = f;
        f.nextSibling = d
    } else {
        d.previousSibling = null
    }
    d.nextSibling = a;
    a.previousSibling = d;
    d.setOwnerTree(this.getOwnerTree());
    this.fireEvent("insert", this.ownerTree, this, d, a);
    if (c) {
        d.fireEvent("move", this.ownerTree, d, c, this, e, a)
    }
    return d
}, remove:function (b) {
    var a = this.parentNode;
    if (a) {
        a.removeChild(this, b)
    }
    return this
}, removeAll:function (a) {
    var c = this.childNodes, b;
    while ((b = c[0])) {
        this.removeChild(b, a)
    }
    return this
}, getChildAt:function (a) {
    return this.childNodes[a]
}, replaceChild:function (a, c) {
    var b = c ? c.nextSibling : null;
    this.removeChild(c);
    this.insertBefore(a, b);
    return c
}, indexOf:function (a) {
    return this.childNodes.indexOf(a)
}, getOwnerTree:function () {
    if (!this.ownerTree) {
        var a = this;
        while (a) {
            if (a.ownerTree) {
                this.ownerTree = a.ownerTree;
                break
            }
            a = a.parentNode
        }
    }
    return this.ownerTree
}, getDepth:function () {
    var b = 0, a = this;
    while (a.parentNode) {
        ++b;
        a = a.parentNode
    }
    return b
}, setOwnerTree:function (a, b) {
    if (a != this.ownerTree) {
        if (this.ownerTree) {
            this.ownerTree.unregisterNode(this)
        }
        this.ownerTree = a;
        if (b !== true) {
            Ext.each(this.childNodes, function (c) {
                c.setOwnerTree(a)
            })
        }
        if (a) {
            a.registerNode(this)
        }
    }
}, setId:function (b) {
    if (b !== this.id) {
        var a = this.ownerTree;
        if (a) {
            a.unregisterNode(this)
        }
        this.id = this.attributes.id = b;
        if (a) {
            a.registerNode(this)
        }
        this.onIdChange(b)
    }
}, onIdChange:Ext.emptyFn, getPath:function (c) {
    c = c || "id";
    var e = this.parentNode, a = [this.attributes[c]];
    while (e) {
        a.unshift(e.attributes[c]);
        e = e.parentNode
    }
    var d = this.getOwnerTree().pathSeparator;
    return d + a.join(d)
}, bubble:function (c, b, a) {
    var d = this;
    while (d) {
        if (c.apply(b || d, a || [d]) === false) {
            break
        }
        d = d.parentNode
    }
}, cascadeBy:function (d, c, a) {
    if (d.apply(c || this, a || [this]) !== false) {
        var f = this.childNodes, e = f.length, b;
        for (b = 0; b < e; b++) {
            f[b].cascadeBy(d, c, a)
        }
    }
}, eachChild:function (d, c, a) {
    var f = this.childNodes, e = f.length, b;
    for (b = 0; b < e; b++) {
        if (d.apply(c || this, a || [f[b]]) === false) {
            break
        }
    }
}, findChild:function (b, c, a) {
    return this.findChildBy(function () {
        return this.attributes[b] == c
    }, null, a)
}, findChildBy:function (g, f, b) {
    var e = this.childNodes, a = e.length, d = 0, h, c;
    for (; d < a; d++) {
        h = e[d];
        if (g.call(f || h, h) === true) {
            return h
        } else {
            if (b) {
                c = h.findChildBy(g, f, b);
                if (c != null) {
                    return c
                }
            }
        }
    }
    return null
}, sort:function (e, d) {
    var c = this.childNodes, a = c.length, b, g;
    if (a > 0) {
        var f = d ? function () {
            return e.apply(d, arguments)
        } : e;
        c.sort(f);
        for (b = 0; b < a; b++) {
            g = c[b];
            g.previousSibling = c[b - 1];
            g.nextSibling = c[b + 1];
            if (b === 0) {
                this.setFirstChild(g)
            }
            if (b == a - 1) {
                this.setLastChild(g)
            }
        }
    }
}, contains:function (a) {
    return a.isAncestor(this)
}, isAncestor:function (a) {
    var b = this.parentNode;
    while (b) {
        if (b == a) {
            return true
        }
        b = b.parentNode
    }
    return false
}, toString:function () {
    return"[Node" + (this.id ? " " + this.id : "") + "]"
}});
Ext.data.RecordNode = Ext.extend(Ext.data.Node, {constructor:function (a) {
    a = a || {};
    if (a.record) {
        a.record.node = this
    }
    Ext.data.RecordNode.superclass.constructor.call(this, a)
}, getChildRecords:function () {
    var e = this.childNodes, d = e.length, b = 0, a = [], c;
    for (; b < d; b++) {
        c = e[b].attributes.record;
        c.data.leaf = e[b].leaf;
        a.push(c)
    }
    return a
}, getRecord:function () {
    return this.attributes.record
}, getSubStore:function () {
    if (this.isLeaf()) {
        throw"Attempted to get a substore of a leaf node."
    }
    var b = this.getOwnerTree().treeStore;
    if (!this.subStore) {
        this.subStore = new Ext.data.Store({model:b.model});
        var a = this.getChildRecords();
        this.subStore.add.apply(this.subStore, a)
    }
    if (!this.loaded) {
        b.load({node:this})
    }
    return this.subStore
}, destroy:function (b) {
    if (this.subStore) {
        this.subStore.destroyStore()
    }
    var a = this.attributes;
    if (a.record) {
        delete a.record.node;
        delete a.record
    }
    return Ext.data.RecordNode.superclass.destroy.call(this, b)
}});
Ext.data.Proxy = Ext.extend(Ext.util.Observable, {batchOrder:"create,update,destroy", defaultReaderType:"json", defaultWriterType:"json", constructor:function (a) {
    a = a || {};
    if (a.model == undefined) {
        delete a.model
    }
    Ext.data.Proxy.superclass.constructor.call(this, a);
    if (this.model != undefined && !(this.model instanceof Ext.data.Model)) {
        this.setModel(this.model)
    }
}, setModel:function (b, c) {
    this.model = Ext.ModelMgr.getModel(b);
    var a = this.reader, d = this.writer;
    this.setReader(a);
    this.setWriter(d);
    if (c && this.store) {
        this.store.setModel(this.model)
    }
}, getModel:function () {
    return this.model
}, setReader:function (a) {
    if (a == undefined || typeof a == "string") {
        a = {type:a}
    }
    if (a instanceof Ext.data.Reader) {
        a.setModel(this.model)
    } else {
        Ext.applyIf(a, {proxy:this, model:this.model, type:this.defaultReaderType});
        a = Ext.data.ReaderMgr.create(a)
    }
    this.reader = a;
    return this.reader
}, getReader:function () {
    return this.reader
}, setWriter:function (a) {
    if (a == undefined || typeof a == "string") {
        a = {type:a}
    }
    if (!(a instanceof Ext.data.Writer)) {
        Ext.applyIf(a, {model:this.model, type:this.defaultWriterType});
        a = Ext.data.WriterMgr.create(a)
    }
    this.writer = a;
    return this.writer
}, getWriter:function () {
    return this.writer
}, create:Ext.emptyFn, read:Ext.emptyFn, update:Ext.emptyFn, destroy:Ext.emptyFn, batch:function (b, c) {
    var a = new Ext.data.Batch({proxy:this, listeners:c || {}});
    Ext.each(this.batchOrder.split(","), function (d) {
        if (b[d]) {
            a.add(new Ext.data.Operation({action:d, records:b[d]}))
        }
    }, this);
    a.start();
    return a
}});
Ext.data.DataProxy = Ext.data.Proxy;
Ext.data.ProxyMgr.registerType("proxy", Ext.data.Proxy);
Ext.data.ServerProxy = Ext.extend(Ext.data.Proxy, {pageParam:"page", startParam:"start", limitParam:"limit", groupParam:"group", sortParam:"sort", filterParam:"filter", noCache:true, cacheString:"_dc", timeout:30000, constructor:function (a) {
    a = a || {};
    Ext.data.ServerProxy.superclass.constructor.call(this, a);
    this.extraParams = a.extraParams || {};
    this.nocache = this.noCache
}, create:function () {
    return this.doRequest.apply(this, arguments)
}, read:function () {
    return this.doRequest.apply(this, arguments)
}, update:function () {
    return this.doRequest.apply(this, arguments)
}, destroy:function () {
    return this.doRequest.apply(this, arguments)
}, buildRequest:function (a) {
    var c = Ext.applyIf(a.params || {}, this.extraParams || {});
    c = Ext.applyIf(c, this.getParams(c, a));
    var b = new Ext.data.Request({params:c, action:a.action, records:a.records, operation:a});
    b.url = this.buildUrl(b);
    a.request = b;
    return b
}, encodeSorters:function (d) {
    var b = [], c = d.length, a;
    for (a = 0; a < c; a++) {
        b[a] = {property:d[a].property, direction:d[a].direction}
    }
    return Ext.encode(b)
}, encodeFilters:function (d) {
    var b = [], c = d.length, a;
    for (a = 0; a < c; a++) {
        b[a] = {property:d[a].property, value:d[a].value}
    }
    return Ext.encode(b)
}, encodeGroupers:function (a) {
    return Ext.encode(a)
}, getParams:function (e, f) {
    e = e || {};
    var l = f.group, k = f.sorters, d = f.filters, j = f.page, b = f.start, g = f.limit, n = this.pageParam, i = this.startParam, m = this.limitParam, h = this.groupParam, c = this.sortParam, a = this.filterParam;
    if (n && j) {
        e[n] = j
    }
    if (i && b) {
        e[i] = b
    }
    if (m && g) {
        e[m] = g
    }
    if (h && l && l.field) {
        e[h] = this.encodeGroupers(l)
    }
    if (c && k && k.length > 0) {
        e[c] = this.encodeSorters(k)
    }
    if (a && d && d.length > 0) {
        e[a] = this.encodeFilters(d)
    }
    return e
}, buildUrl:function (b) {
    var a = b.url || this.url;
    if (!a) {
        throw new Error("You are using a ServerProxy but have not supplied it with a url.")
    }
    if (this.noCache) {
        a = Ext.urlAppend(a, Ext.util.Format.format("{0}={1}", this.cacheString, (new Date().getTime())))
    }
    return a
}, doRequest:function (a, c, b) {
    throw new Error("The doRequest function has not been implemented on your Ext.data.ServerProxy subclass. See src/data/ServerProxy.js for details")
}, afterRequest:Ext.emptyFn, onDestroy:function () {
    Ext.destroy(this.reader, this.writer);
    Ext.data.ServerProxy.superclass.destroy.apply(this, arguments)
}});
Ext.data.AjaxProxy = Ext.extend(Ext.data.ServerProxy, {actionMethods:{create:"POST", read:"GET", update:"POST", destroy:"POST"}, constructor:function () {
    this.addEvents("exception");
    Ext.data.AjaxProxy.superclass.constructor.apply(this, arguments)
}, doRequest:function (a, e, b) {
    var d = this.getWriter(), c = this.buildRequest(a, e, b);
    if (a.allowWrite()) {
        c = d.write(c)
    }
    Ext.apply(c, {headers:this.headers, timeout:this.timeout, scope:this, callback:this.createRequestCallback(c, a, e, b), method:this.getMethod(c), disableCaching:false});
    Ext.Ajax.request(c);
    return c
}, getMethod:function (a) {
    return this.actionMethods[a.action]
}, createRequestCallback:function (d, a, e, b) {
    var c = this;
    return function (o, n, h) {
        if (n === true) {
            var l = c.getReader(), p = l.read(h), g = p.records, f = g.length, m = new Ext.util.MixedCollection(true, function (i) {
                return i.getId()
            }), k, j;
            m.addAll(a.records);
            for (j = 0; j < f; j++) {
                k = m.get(g[j].getId());
                if (k) {
                    k.set(k.data)
                }
            }
            Ext.apply(a, {response:h, resultSet:p});
            a.setCompleted();
            a.setSuccessful()
        } else {
            c.fireEvent("exception", this, h, a);
            a.setException()
        }
        if (typeof e == "function") {
            e.call(b || c, a)
        }
        c.afterRequest(d, true)
    }
}});
Ext.data.ProxyMgr.registerType("ajax", Ext.data.AjaxProxy);
Ext.data.HttpProxy = Ext.data.AjaxProxy;
Ext.data.RestProxy = Ext.extend(Ext.data.AjaxProxy, {appendId:true, actionMethods:{create:"POST", read:"GET", update:"PUT", destroy:"DELETE"}, api:{create:"create", read:"read", update:"update", destroy:"destroy"}, buildUrl:function (d) {
    var b = d.operation.records || [], a = b[0], e = this.format, c = d.url || this.url;
    if (this.appendId && a) {
        if (!c.match(/\/$/)) {
            c += "/"
        }
        c += a.getId()
    }
    if (e) {
        if (!c.match(/\.$/)) {
            c += "."
        }
        c += e
    }
    d.url = c;
    return Ext.data.RestProxy.superclass.buildUrl.apply(this, arguments)
}});
Ext.data.ProxyMgr.registerType("rest", Ext.data.RestProxy);
Ext.apply(Ext, {getHead:function () {
    var a;
    return function () {
        if (a == undefined) {
            a = Ext.get(document.getElementsByTagName("head")[0])
        }
        return a
    }
}()});
Ext.data.ScriptTagProxy = Ext.extend(Ext.data.ServerProxy, {defaultWriterType:"base", callbackParam:"callback", scriptIdPrefix:"stcScript", callbackPrefix:"stcCallback", recordParam:"records", lastRequest:undefined, autoAppendParams:true, constructor:function () {
    this.addEvents("exception");
    Ext.data.ScriptTagProxy.superclass.constructor.apply(this, arguments)
}, doRequest:function (f, j, k) {
    var i = Ext.util.Format.format, a = ++Ext.data.ScriptTagProxy.TRANS_ID, c = i("{0}{1}", this.scriptIdPrefix, a), d = i("{0}{1}", this.callbackPrefix, a);
    var e = this.getWriter(), g = this.buildRequest(f), b = Ext.urlAppend(g.url, i("{0}={1}", this.callbackParam, d));
    if (f.allowWrite()) {
        g = e.write(g)
    }
    Ext.apply(g, {url:b, transId:a, scriptId:c, stCallback:d});
    g.timeoutId = Ext.defer(this.createTimeoutHandler, this.timeout, this, [g, f]);
    window[d] = this.createRequestCallback(g, f, j, k);
    var h = document.createElement("script");
    h.setAttribute("src", b);
    h.setAttribute("async", true);
    h.setAttribute("type", "text/javascript");
    h.setAttribute("id", c);
    Ext.getHead().appendChild(h);
    f.setStarted();
    this.lastRequest = g;
    return g
}, createRequestCallback:function (d, a, e, b) {
    var c = this;
    return function (h) {
        var g = c.getReader(), f = g.read(h);
        Ext.apply(a, {response:h, resultSet:f});
        a.setCompleted();
        a.setSuccessful();
        if (typeof e == "function") {
            e.call(b || c, a)
        }
        c.afterRequest(d, true)
    }
}, afterRequest:function () {
    var a = function (b) {
        return function () {
            window[b] = undefined;
            try {
                delete window[b]
            } catch (c) {
            }
        }
    };
    return function (c, b) {
        Ext.get(c.scriptId).remove();
        clearTimeout(c.timeoutId);
        var d = c.stCallback;
        if (b) {
            a(d)();
            this.lastRequest.completed = true
        } else {
            window[d] = a(d)
        }
    }
}(), buildUrl:function (f) {
    var b = Ext.data.ScriptTagProxy.superclass.buildUrl.call(this, f), g = Ext.apply({}, f.params), e = g.filters, d, c;
    delete g.filters;
    if (this.autoAppendParams) {
        b = Ext.urlAppend(b, Ext.urlEncode(g))
    }
    if (e && e.length) {
        for (c = 0; c < e.length; c++) {
            d = e[c];
            if (d.value) {
                b = Ext.urlAppend(b, d.property + "=" + d.value)
            }
        }
    }
    var a = f.records;
    if (Ext.isArray(a) && a.length > 0) {
        b = Ext.urlAppend(b, Ext.util.Format.format("{0}={1}", this.recordParam, this.encodeRecords(a)))
    }
    return b
}, destroy:function () {
    this.abort();
    Ext.data.ScriptTagProxy.superclass.destroy.apply(this, arguments)
}, isLoading:function () {
    var a = this.lastRequest;
    return(a != undefined && !a.completed)
}, abort:function () {
    if (this.isLoading()) {
        this.afterRequest(this.lastRequest)
    }
}, encodeRecords:function (a) {
    var d = "";
    for (var b = 0, c = a.length; b < c; b++) {
        d += Ext.urlEncode(a[b].data)
    }
    return d
}, createTimeoutHandler:function (b, a) {
    this.afterRequest(b, false);
    this.fireEvent("exception", this, b, a);
    if (typeof b.callback == "function") {
        b.callback.call(b.scope || window, null, b.options, false)
    }
}});
Ext.data.ScriptTagProxy.TRANS_ID = 1000;
Ext.data.ProxyMgr.registerType("scripttag", Ext.data.ScriptTagProxy);
Ext.data.ClientProxy = Ext.extend(Ext.data.Proxy, {clear:function () {
    throw new Error("The Ext.data.ClientProxy subclass that you are using has not defined a 'clear' function. See src/data/ClientProxy.js for details.")
}});
Ext.data.MemoryProxy = Ext.extend(Ext.data.ClientProxy, {constructor:function (a) {
    Ext.data.MemoryProxy.superclass.constructor.call(this, a);
    this.setReader(this.reader)
}, read:function (c, e, d) {
    var b = this.getReader(), a = b.read(this.data);
    Ext.apply(c, {resultSet:a});
    c.setCompleted();
    if (typeof e == "function") {
        e.call(d || this, c)
    }
}, clear:Ext.emptyFn});
Ext.data.ProxyMgr.registerType("memory", Ext.data.MemoryProxy);
Ext.data.WebStorageProxy = Ext.extend(Ext.data.ClientProxy, {id:undefined, constructor:function (a) {
    Ext.data.WebStorageProxy.superclass.constructor.call(this, a);
    this.cache = {};
    if (this.getStorageObject() == undefined) {
        throw"Local Storage is not supported in this browser, please use another type of data proxy"
    }
    this.id = this.id || (this.store ? this.store.storeId : undefined);
    if (this.id == undefined) {
        throw"No unique id was provided to the local storage proxy. See Ext.data.LocalStorageProxy documentation for details"
    }
    this.initialize()
}, create:function (e, h, j) {
    var d = e.records, c = d.length, a = this.getIds(), b, g, f;
    e.setStarted();
    for (f = 0; f < c; f++) {
        g = d[f];
        if (g.phantom) {
            g.phantom = false;
            b = this.getNextId()
        } else {
            b = g.getId()
        }
        this.setRecord(g, b);
        a.push(b)
    }
    this.setIds(a);
    e.setCompleted();
    e.setSuccessful();
    if (typeof h == "function") {
        h.call(j || this, e)
    }
}, read:function (e, h, j) {
    var d = [], a = this.getIds(), c = a.length, f, b, g;
    if (e.id) {
        g = this.getRecord(e.id);
        if (g) {
            d.push(g);
            e.setSuccessful()
        }
    } else {
        for (f = 0; f < c; f++) {
            d.push(this.getRecord(a[f]))
        }
        e.setSuccessful()
    }
    e.setCompleted();
    e.resultSet = new Ext.data.ResultSet({records:d, total:d.length, loaded:true});
    if (typeof h == "function") {
        h.call(j || this, e)
    }
}, update:function (e, h, j) {
    var d = e.records, c = d.length, a = this.getIds(), g, b, f;
    e.setStarted();
    for (f = 0; f < c; f++) {
        g = d[f];
        this.setRecord(g);
        b = g.getId();
        if (b !== undefined && a.indexOf(b) == -1) {
            a.push(b)
        }
    }
    this.setIds(a);
    e.setCompleted();
    e.setSuccessful();
    if (typeof h == "function") {
        h.call(j || this, e)
    }
}, destroy:function (b, h, e) {
    var a = b.records, f = a.length, d = this.getIds(), g = [].concat(d), c;
    for (c = 0; c < f; c++) {
        g.remove(a[c].getId());
        this.removeRecord(a[c], false)
    }
    this.setIds(g);
    if (typeof h == "function") {
        h.call(e || this, b)
    }
}, getRecord:function (c) {
    if (this.cache[c] == undefined) {
        var a = Ext.decode(this.getStorageObject().getItem(this.getRecordKey(c))), f = {}, e = this.model, j = e.prototype.fields.items, d = j.length, g, k, b, h;
        for (g = 0; g < d; g++) {
            k = j[g];
            b = k.name;
            if (typeof k.decode == "function") {
                f[b] = k.decode(a[b])
            } else {
                f[b] = a[b]
            }
        }
        h = new e(f, c);
        h.phantom = false;
        this.cache[c] = h
    }
    return this.cache[c]
}, setRecord:function (j, c) {
    if (c) {
        j.setId(c)
    } else {
        c = j.getId()
    }
    var a = j.data, f = {}, h = this.model, k = h.prototype.fields.items, d = k.length, g, l, b;
    for (g = 0; g < d; g++) {
        l = k[g];
        b = l.name;
        if (typeof l.encode == "function") {
            f[b] = l.encode(a[b], j)
        } else {
            f[b] = a[b]
        }
    }
    var e = this.getStorageObject(), m = this.getRecordKey(c);
    this.cache[c] = j;
    e.removeItem(m);
    e.setItem(m, Ext.encode(f))
}, removeRecord:function (c, b) {
    if (c instanceof Ext.data.Model) {
        c = c.getId()
    }
    if (b !== false) {
        var a = this.getIds();
        a.remove(c);
        this.setIds(a)
    }
    this.getStorageObject().removeItem(this.getRecordKey(c))
}, getRecordKey:function (a) {
    if (a instanceof Ext.data.Model) {
        a = a.getId()
    }
    return Ext.util.Format.format("{0}-{1}", this.id, a)
}, getRecordCounterKey:function () {
    return Ext.util.Format.format("{0}-counter", this.id)
}, getIds:function () {
    var b = (this.getStorageObject().getItem(this.id) || "").split(","), c = b.length, a;
    if (c == 1 && b[0] == "") {
        b = []
    } else {
        for (a = 0; a < c; a++) {
            b[a] = parseInt(b[a], 10)
        }
    }
    return b
}, setIds:function (a) {
    var b = this.getStorageObject(), c = a.join(",");
    b.removeItem(this.id);
    if (!Ext.isEmpty(c)) {
        b.setItem(this.id, c)
    }
}, getNextId:function () {
    var d = this.getStorageObject(), a = this.getRecordCounterKey(), c = d[a], b, e;
    if (c == undefined) {
        b = this.getIds();
        c = b[b.length - 1] || 0
    }
    e = parseInt(c, 10) + 1;
    d.setItem(a, e);
    return e
}, initialize:function () {
    var a = this.getStorageObject();
    a.setItem(this.id, a.getItem(this.id) || "")
}, clear:function () {
    var d = this.getStorageObject(), c = this.getIds(), a = c.length, b;
    for (b = 0; b < a; b++) {
        this.removeRecord(c[b])
    }
    d.removeItem(this.getRecordCounterKey());
    d.removeItem(this.id)
}, getStorageObject:function () {
    throw new Error("The getStorageObject function has not been defined in your Ext.data.WebStorageProxy subclass")
}});
Ext.data.LocalStorageProxy = Ext.extend(Ext.data.WebStorageProxy, {getStorageObject:function () {
    return window.localStorage
}});
Ext.data.ProxyMgr.registerType("localstorage", Ext.data.LocalStorageProxy);
Ext.data.SessionStorageProxy = Ext.extend(Ext.data.WebStorageProxy, {getStorageObject:function () {
    return window.sessionStorage
}});
Ext.data.ProxyMgr.registerType("sessionstorage", Ext.data.SessionStorageProxy);
Ext.data.Reader = Ext.extend(Object, {idProperty:"id", totalProperty:"total", successProperty:"success", root:"", implicitIncludes:true, nullResultSet:new Ext.data.ResultSet({total:0, count:0, records:[], success:true}), constructor:function (a) {
    Ext.apply(this, a || {});
    this.model = Ext.ModelMgr.getModel(a.model);
    if (this.model) {
        this.buildExtractors()
    }
}, setModel:function (a, b) {
    this.model = Ext.ModelMgr.getModel(a);
    this.buildExtractors(true);
    if (b && this.proxy) {
        this.proxy.setModel(this.model, true)
    }
}, read:function (a) {
    var b = a;
    if (a && a.responseText) {
        b = this.getResponseData(a)
    }
    if (b) {
        return this.readRecords(b)
    } else {
        return this.nullResultSet
    }
}, readRecords:function (f) {
    this.rawData = f;
    f = this.getData(f);
    var a = this.getRoot(f), d = a.length, g = true, e, b, c;
    if (this.totalProperty) {
        e = parseInt(this.getTotal(f), 10);
        if (!isNaN(e)) {
            d = e
        }
    }
    if (this.successProperty) {
        e = this.getSuccess(f);
        if (e === false || e === "false") {
            g = false
        }
    }
    b = this.extractData(a, true);
    c = b.length;
    return new Ext.data.ResultSet({total:d || c, count:c, records:b, success:g})
}, extractData:function (j, a) {
    var k = [], f = [], d = this.model, c = j.length, l = this.idProperty, e, b, h, g;
    for (g = 0; g < c; g++) {
        e = j[g];
        k = this.extractValues(e);
        b = this.getId(e);
        if (a === true) {
            h = new d(k, b);
            h.raw = e;
            f.push(h);
            if (this.implicitIncludes) {
                this.readAssociated(h, e)
            }
        } else {
            k[l] = b;
            f.push(k)
        }
    }
    return f
}, readAssociated:function (h, g) {
    var e = h.associations.items, a = e.length, d, m, n, c, b, k, j, l, f;
    for (f = 0; f < a; f++) {
        d = e[f];
        m = d.name;
        c = this.getAssociatedDataRoot(g, d.associationKey || m);
        n = d.associatedModel;
        if (c) {
            k = n.proxy;
            if (k) {
                j = k.getReader()
            } else {
                j = new this.constructor({model:d.associatedName})
            }
            if (d.type == "hasMany") {
                l = h[m]();
                l.add.apply(l, j.read(c).records);
                b = n.prototype.associations.findBy(function (i) {
                    return i.type == "belongsTo" && i.associatedName == h.constructor.modelName
                });
                if (b) {
                    l.data.each(function (i) {
                        i[b.instanceName] = h
                    })
                }
            } else {
                if (d.type == "belongsTo") {
                    h[d.instanceName] = j.read([c]).records[0]
                }
            }
        }
    }
}, getAssociatedDataRoot:function (b, a) {
    return b[a]
}, extractValues:function (f) {
    var a = this.model.prototype.fields.items, d = a.length, b = {}, g, e, c;
    for (c = 0; c < d; c++) {
        g = a[c];
        e = this.extractorFunctions[c](f) || g.defaultValue;
        b[g.name] = e
    }
    return b
}, getData:function (a) {
    return a
}, getRoot:function (a) {
    return a
}, getResponseData:function (a) {
    throw new Error("getResponseData must be implemented in the Ext.data.Reader subclass")
}, onMetaChange:function (c) {
    var a = c.fields, b;
    Ext.apply(this, c);
    if (a) {
        b = Ext.regModel("JsonReader-Model" + Ext.id(), {fields:a});
        this.setModel(b, true)
    } else {
        this.buildExtractors(true)
    }
}, buildExtractors:function (d) {
    if (d === true) {
        delete this.extractorFunctions
    }
    if (this.extractorFunctions) {
        return
    }
    var f = this.id || this.idProperty, c = this.totalProperty, b = this.successProperty, e = this.messageProperty;
    if (c) {
        this.getTotal = this.createAccessor(c)
    }
    if (b) {
        this.getSuccess = this.createAccessor(b)
    }
    if (e) {
        this.getMessage = this.createAccessor(e)
    }
    if (f) {
        var a = this.createAccessor(f);
        this.getId = function (g) {
            var h = a(g);
            return(h == undefined || h == "") ? null : h
        }
    } else {
        this.getId = function () {
            return null
        }
    }
    this.buildFieldExtractors()
}, buildFieldExtractors:function () {
    var a = this.model.prototype.fields.items, c = a.length, b = 0, f = [], e, d;
    for (; b < c; b++) {
        e = a[b];
        d = (e.mapping !== undefined && e.mapping !== null) ? e.mapping : e.name;
        f.push(this.createAccessor(d))
    }
    this.extractorFunctions = f
}});
Ext.data.Writer = Ext.extend(Object, {constructor:function (a) {
    Ext.apply(this, a)
}, write:function (e) {
    var b = e.operation, a = b.records || [], d = a.length, c = 0, f = [];
    for (; c < d; c++) {
        f.push(this.getRecordData(a[c]))
    }
    return this.writeRecords(e, f)
}, getRecordData:function (a) {
    return a.data
}});
Ext.data.WriterMgr.registerType("base", Ext.data.Writer);
Ext.data.JsonWriter = Ext.extend(Ext.data.Writer, {root:"records", encode:false, writeRecords:function (a, b) {
    if (this.encode === true) {
        b = Ext.encode(b)
    }
    a.jsonData = a.jsonData || {};
    a.jsonData[this.root] = b;
    return a
}});
Ext.data.WriterMgr.registerType("json", Ext.data.JsonWriter);
Ext.data.JsonReader = Ext.extend(Ext.data.Reader, {root:"", readRecords:function (a) {
    if (a.metaData) {
        this.onMetaChange(a.metaData)
    }
    this.jsonData = a;
    return Ext.data.JsonReader.superclass.readRecords.call(this, a)
}, getResponseData:function (a) {
    try {
        var c = Ext.decode(a.responseText)
    } catch (b) {
        throw"Ext.data.JsonReader.getResponseData: Unable to parse JSON returned by Server."
    }
    if (!c) {
        throw"Ext.data.JsonReader.getResponseData: JSON object not found"
    }
    return c
}, buildExtractors:function () {
    Ext.data.JsonReader.superclass.buildExtractors.apply(this, arguments);
    if (this.root) {
        this.getRoot = this.createAccessor(this.root)
    } else {
        this.getRoot = function (a) {
            return a
        }
    }
}, extractData:function (a, c) {
    var f = this.record, e = [], d, b;
    if (f) {
        d = a.length;
        for (b = 0; b < d; b++) {
            e[b] = a[b][f]
        }
    } else {
        e = a
    }
    return Ext.data.JsonReader.superclass.extractData.call(this, e, c)
}, createAccessor:function () {
    var a = /[\[\.]/;
    return function (c) {
        if (Ext.isEmpty(c)) {
            return Ext.emptyFn
        }
        if (Ext.isFunction(c)) {
            return c
        }
        var b = String(c).search(a);
        if (b >= 0) {
            return new Function("obj", "return obj" + (b > 0 ? "." : "") + c)
        }
        return function (d) {
            return d[c]
        }
    }
}()});
Ext.data.ReaderMgr.registerType("json", Ext.data.JsonReader);
Ext.data.TreeReader = Ext.extend(Ext.data.JsonReader, {extractData:function (b, e) {
    var c = Ext.data.TreeReader.superclass.extractData.call(this, b, e), f = c.length, d = 0, a;
    if (e) {
        for (; d < f; d++) {
            a = c[d];
            a.doPreload = !!this.getRoot(a.raw)
        }
    }
    return c
}});
Ext.data.ReaderMgr.registerType("tree", Ext.data.TreeReader);
Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {buildExtractors:function () {
    Ext.data.ArrayReader.superclass.buildExtractors.apply(this, arguments);
    var a = this.model.prototype.fields.items, c = a.length, d = [], b;
    for (b = 0; b < c; b++) {
        d.push(function (e) {
            return function (f) {
                return f[e]
            }
        }(a[b].mapping || b))
    }
    this.extractorFunctions = d
}});
Ext.data.ReaderMgr.registerType("array", Ext.data.ArrayReader);
Ext.data.ArrayStore = Ext.extend(Ext.data.Store, {constructor:function (a) {
    a = a || {};
    Ext.applyIf(a, {proxy:{type:"memory", reader:"array"}});
    Ext.data.ArrayStore.superclass.constructor.call(this, a)
}, loadData:function (e, a) {
    if (this.expandData === true) {
        var d = [], b = 0, c = e.length;
        for (; b < c; b++) {
            d[d.length] = [e[b]]
        }
        e = d
    }
    Ext.data.ArrayStore.superclass.loadData.call(this, e, a)
}});
Ext.reg("arraystore", Ext.data.ArrayStore);
Ext.data.SimpleStore = Ext.data.ArrayStore;
Ext.reg("simplestore", Ext.data.SimpleStore);
Ext.data.JsonStore = Ext.extend(Ext.data.Store, {constructor:function (a) {
    a = a || {};
    Ext.applyIf(a, {proxy:{type:"ajax", reader:"json", writer:"json"}});
    Ext.data.JsonStore.superclass.constructor.call(this, a)
}});
Ext.reg("jsonstore", Ext.data.JsonStore);
Ext.data.JsonPStore = Ext.extend(Ext.data.Store, {constructor:function (a) {
    Ext.data.JsonPStore.superclass.constructor.call(this, Ext.apply(a, {reader:new Ext.data.JsonReader(a), proxy:new Ext.data.ScriptTagProxy(a)}))
}});
Ext.reg("jsonpstore", Ext.data.JsonPStore);
Ext.data.XmlWriter = Ext.extend(Ext.data.Writer, {documentRoot:"xmlData", header:"", record:"record", writeRecords:function (b, c) {
    var a = this.buildTpl(b, c);
    b.xmlData = a.apply(c);
    return b
}, buildTpl:function (e, f) {
    if (this.tpl) {
        return this.tpl
    }
    var c = [], b = this.documentRoot, a = this.record, g, d;
    if (this.header) {
        c.push(this.header)
    }
    c.push("<", b, ">");
    if (f.length > 0) {
        c.push('<tpl for="."><', a, ">");
        g = f[0];
        for (d in g) {
            if (g.hasOwnProperty(d)) {
                c.push("<", d, ">{", d, "}</", d, ">")
            }
        }
        c.push("</", a, "></tpl>")
    }
    c.push("</", b, ">");
    this.tpl = new Ext.XTemplate(c.join(""));
    return this.tpl
}});
Ext.data.WriterMgr.registerType("xml", Ext.data.XmlWriter);
Ext.data.XmlReader = Ext.extend(Ext.data.Reader, {createAccessor:function () {
    var a = function (d, c, b) {
        var e = Ext.DomQuery.selectNode(d, c), f;
        if (e && e.firstChild) {
            f = e.firstChild.nodeValue
        }
        return Ext.isEmpty(f) ? b : f
    };
    return function (b) {
        var c;
        if (b == this.totalProperty) {
            c = function (e, d) {
                var f = a(b, e, d);
                return parseFloat(f)
            }
        } else {
            if (b == this.successProperty) {
                c = function (e, d) {
                    var f = a(b, e, true);
                    return(f !== false && f !== "false")
                }
            } else {
                c = function (e, d) {
                    return a(b, e, d)
                }
            }
        }
        return c
    }
}(), getResponseData:function (a) {
    var b = a.responseXML;
    if (!b) {
        throw {message:"Ext.data.XmlReader.read: XML data not found"}
    }
    return b
}, getData:function (a) {
    return a.documentElement || a
}, getRoot:function (b) {
    var c = b.nodeName, a = this.root;
    if (!a || (c && c == a)) {
        return b
    } else {
        return Ext.DomQuery.selectNode(a, b)
    }
}, constructor:function (a) {
    a = a || {};
    Ext.applyIf(a, {idProperty:a.idPath || a.id, successProperty:a.success});
    Ext.data.XmlReader.superclass.constructor.call(this, a)
}, extractData:function (a, b) {
    var c = this.record;
    if (c != a.nodeName) {
        a = Ext.DomQuery.select(c, a)
    } else {
        a = [a]
    }
    return Ext.data.XmlReader.superclass.extractData.call(this, a, b)
}, getAssociatedDataRoot:function (b, a) {
    return Ext.DomQuery.select(a, b)[0]
}, readRecords:function (a) {
    if (Ext.isArray(a)) {
        a = a[0]
    }
    this.xmlData = a;
    return Ext.data.XmlReader.superclass.readRecords.call(this, a)
}});
Ext.data.ReaderMgr.registerType("xml", Ext.data.XmlReader);
Ext.data.XmlStore = Ext.extend(Ext.data.Store, {constructor:function (a) {
    a = a || {};
    a = a || {};
    Ext.applyIf(a, {proxy:{type:"ajax", reader:"xml", writer:"xml"}});
    Ext.data.XmlStore.superclass.constructor.call(this, a)
}});
Ext.reg("xmlstore", Ext.data.XmlStore);
Ext.History = new Ext.util.Observable({constructor:function () {
    Ext.History.superclass.constructor.call(this, config);
    this.addEvents("change")
}, init:function () {
    var a = this;
    a.setToken(window.location.hash);
    if (Ext.supports.History) {
        window.addEventListener("hashchange", this.onChange)
    } else {
        setInterval(function () {
            var c = a.cleanToken(window.location.hash), b = a.getToken();
            if (c != b) {
                a.onChange()
            }
        }, 50)
    }
}, onChange:function () {
    var b = Ext.History, a = b.cleanToken(window.location.hash);
    if (b.token != a) {
        b.fireEvent("change", a)
    }
    b.setToken(a)
}, setToken:function (a) {
    return this.token = this.cleanToken(a)
}, cleanToken:function (a) {
    return a[0] == "#" ? a.substr(1) : a
}, getToken:function () {
    return this.token
}, add:function (a) {
    window.location.hash = this.setToken(a);
    if (!Ext.supports.History) {
        this.onChange()
    }
}});
Ext.ControllerManager = new Ext.AbstractManager({register:function (c, b) {
    b.id = c;
    Ext.applyIf(b, {application:Ext.ApplicationManager.currentApplication});
    var a = new Ext.Controller(b);
    if (a.init) {
        a.init()
    }
    this.all.add(a);
    return a
}});
Ext.regController = function () {
    return Ext.ControllerManager.register.apply(Ext.ControllerManager, arguments)
};
Ext.Controller = Ext.extend(Ext.util.Observable, {constructor:function (a) {
    this.addEvents("instance-created", "instance-creation-failed", "instance-updated", "instance-update-failed", "instance-destroyed", "instance-destruction-failed");
    Ext.Controller.superclass.constructor.call(this, a);
    Ext.apply(this, a || {});
    if (typeof this.model == "string") {
        this.model = Ext.ModelMgr.getModel(this.model)
    }
}, index:function () {
    this.render("index", {listeners:{scope:this, edit:this.edit, build:this.build, create:this.onCreateInstance, destroy:this.onDestroyInstance}})
}, edit:function (a) {
    var b = this.render("edit", {listeners:this.getEditListeners()});
    b.loadModel(a)
}, build:function () {
    this.render("build", {listeners:this.getBuildListeners()})
}, create:function (f, c) {
    c = c || {};
    var b = this.getModel(), a = new b(f), e = c.success, g = c.failure, d = c.scope || this;
    a.save({scope:this, success:function (h) {
        if (typeof e == "function") {
            e.call(d, h)
        }
        this.fireEvent("instance-created", h)
    }, failure:function (h, i) {
        if (typeof g == "function") {
            g.call(d, h, i)
        }
        this.fireEvent("instance-creation-failed", h, i)
    }})
}, update:function (a, e, b) {
    b = b || {};
    var d = b.success, f = b.failure, c = b.scope || this;
    if (Ext.isObject(e)) {
        a.set(e)
    }
    a.save({scope:this, success:function (g) {
        if (typeof d == "function") {
            d.call(c, g)
        }
        this.fireEvent("instance-updated", g)
    }, failure:function (g, h) {
        if (typeof f == "function") {
            f.call(c, g, h)
        }
        this.fireEvent("instance-update-failed", g, h)
    }})
}, destroy:function (a, b) {
    b = b || {};
    var d = b.success, e = b.failure, c = b.scope || this;
    a.destroy({scope:this, success:function (f) {
        if (typeof d == "function") {
            d.call(c, f)
        }
        this.fireEvent("instance-destroyed", f)
    }, failure:function (f, g) {
        if (typeof e == "function") {
            e.call(c, f, g)
        }
        this.fireEvent("instance-destruction-failed", f, g)
    }})
}, getBuildListeners:function () {
    return{scope:this, save:this.onCreateInstance, cancel:this.onCancelBuild}
}, getEditListeners:function () {
    return{scope:this, save:this.onUpdateInstance, cancel:this.onCancelEdit}
}, onCancelEdit:function (a) {
    return this.closeView(a)
}, onCancelBuild:function (a) {
    return this.closeView(a)
}, onCreateInstance:function (a) {
    this.create(a.getValues(), {scope:this, success:function (b) {
        this.closeView(a)
    }, failure:function (b, c) {
        console.log("fail")
    }})
}, onUpdateInstance:function (a) {
    this.update(a.getRecord(), a.getValues(), {scope:this, success:function (b) {
        this.closeView(a)
    }, failure:function (b, c) {
    }})
}, onDestroyInstance:function (a, b) {
    this.destroy(a, {scope:this, success:function (c) {
    }, failure:function (c, d) {
    }})
}, setRenderTarget:function (a) {
    Ext.Controller.renderTarget = a
}, render:function (c, g) {
    var f = Ext.Controller, b = this.application, d = b ? b.currentProfile : undefined, e, a;
    Ext.applyIf(c, {profile:d});
    a = Ext.ComponentMgr.create(c);
    if (g !== false) {
        e = d ? d.getRenderTarget(c, b) : g;
        if (g == undefined) {
            g = e || (b ? b.defaultTarget : undefined)
        }
        if (typeof g == "string") {
            g = Ext.getCmp(g)
        }
        if (g != undefined && g.add) {
            if (d) {
                d.beforeLayout(a, g, b)
            }
            g.add(a);
            if (g.layout && g.layout.setActiveItem) {
                g.layout.setActiveItem(a)
            }
            g.doComponentLayout();
            if (d) {
                d.afterLayout(a, g, b)
            }
        }
    }
    return a
}, control:function (e, d, i) {
    if (!e || !e.isView) {
        throw"Trying to control a view that doesnt exist"
    }
    var h = i ? e.refs[i] : e, g, f, a, b, c;
    if (!h) {
        throw"No item called " + i + " found inside the " + e.name + " view."
    }
    for (g in d) {
        f = d[g];
        if (Ext.isObject(f) && !f.fn) {
            this.control(e, f, g)
        } else {
            if (h.refs) {
                for (a in h.refs) {
                    b = h.refs[a];
                    if (b.isObservable && b.events[g]) {
                        b.enableBubble(g)
                    }
                }
            }
            if (!f.fn) {
                c = {};
                c[g] = f;
                c.scope = this
            } else {
                c = f;
                if (c.scope === undefined) {
                    c.scope = this
                }
            }
            h.addListener(c)
        }
    }
    return e
}, getModel:function () {
    return Ext.ModelMgr.getModel(this.model)
}, closeView:function (a) {
    var b = a.ownerCt;
    if (b) {
        b.remove(a);
        b.doLayout();
        b.setActiveItem(b.items.last())
    }
}});
Ext.util.Dispatcher = Ext.extend(Ext.util.Observable, {constructor:function (a) {
    this.addEvents("before-dispatch", "dispatch");
    Ext.util.Dispatcher.superclass.constructor.call(this, a)
}, dispatch:function (c) {
    var b = new Ext.Interaction(c), a = b.controller, e = b.action, d = Ext.History;
    if (this.fireEvent("before-dispatch", b) !== false) {
        if (d && c.historyUrl) {
            d.suspendEvents(false);
            d.add(c.historyUrl);
            Ext.defer(d.resumeEvents, 100, d)
        }
        if (a && e) {
            a[e].call(a, b);
            b.dispatched = true
        }
        this.fireEvent("dispatch", b)
    }
}, redirect:function (b) {
    if (b instanceof Ext.data.Model) {
    } else {
        if (typeof b == "string") {
            var a = Ext.Router.recognize(b);
            if (a) {
                return this.dispatch(a)
            }
        }
    }
    return null
}, createRedirect:function (a) {
    return function () {
        Ext.Dispatcher.redirect(a)
    }
}});
Ext.Dispatcher = new Ext.util.Dispatcher();
Ext.dispatch = function () {
    return Ext.Dispatcher.dispatch.apply(Ext.Dispatcher, arguments)
};
Ext.redirect = function () {
    return Ext.Dispatcher.redirect.apply(Ext.Dispatcher, arguments)
};
Ext.createRedirect = Ext.Dispatcher.createRedirect;
Ext.util.Router = Ext.extend(Ext.util.Observable, {constructor:function (a) {
    a = a || {};
    Ext.apply(this, a, {defaults:{action:"index"}});
    this.routes = [];
    Ext.util.Router.superclass.constructor.call(this, a)
}, connect:function (b, c) {
    c = Ext.apply({url:b}, c || {}, this.defaults);
    var a = new Ext.util.Route(c);
    this.routes.push(a);
    return a
}, recognize:function (c) {
    var b = this.routes, e = b.length, d, a;
    for (d = 0; d < e; d++) {
        a = b[d].recognize(c);
        if (a != undefined) {
            return a
        }
    }
    return undefined
}, draw:function (a) {
    a.call(this, this)
}});
Ext.Router = new Ext.util.Router();
Ext.util.Route = Ext.extend(Object, {constructor:function (a) {
    Ext.apply(this, a, {conditions:{}});
    this.paramMatchingRegex = new RegExp(/:([0-9A-Za-z\_]*)/g);
    this.paramsInMatchString = this.url.match(this.paramMatchingRegex) || [];
    this.matcherRegex = this.createMatcherRegex(this.url)
}, recognize:function (a) {
    if (this.recognizes(a)) {
        var b = this.matchesFor(a);
        return Ext.applyIf(b, {controller:this.controller, action:this.action, historyUrl:a})
    }
}, recognizes:function (a) {
    return this.matcherRegex.test(a)
}, matchesFor:function (b) {
    var f = {}, e = this.paramsInMatchString, a = b.match(this.matcherRegex), d = e.length, c;
    a.shift();
    for (c = 0; c < d; c++) {
        f[e[c].replace(":", "")] = a[c]
    }
    return f
}, urlFor:function (a) {
}, createMatcherRegex:function (a) {
    var e = this.paramsInMatchString, d = e.length, b, c, f;
    for (b = 0; b < d; b++) {
        c = this.conditions[e[b]];
        f = Ext.util.Format.format("({0})", c || "[%a-zA-Z0-9\\_\\s,]+");
        a = a.replace(new RegExp(e[b]), f)
    }
    return new RegExp("^" + a + "$")
}});
Ext.Interaction = Ext.extend(Ext.util.Observable, {controller:"", action:"", dispatched:false, constructor:function (a) {
    Ext.Interaction.superclass.constructor.apply(this, arguments);
    a = a || {};
    Ext.applyIf(a, {scope:this});
    Ext.apply(this, a);
    if (typeof this.controller == "string") {
        this.controller = Ext.ControllerManager.get(this.controller)
    }
}});
Ext.Application = Ext.extend(Ext.util.Observable, {scope:undefined, useHistory:true, autoUpdateComponentProfiles:true, setProfilesOnLaunch:true, constructor:function (b) {
    this.addEvents("launch", "beforeprofilechange", "profilechange");
    Ext.Application.superclass.constructor.call(this, b);
    this.bindReady();
    var a = this.name;
    if (a) {
        window[a] = this;
        Ext.ns(a, a + ".views", a + ".stores", a + ".models", a + ".controllers")
    }
    if (Ext.addMetaTags) {
        Ext.addMetaTags(b)
    }
}, bindReady:function () {
    Ext.onReady(this.onReady, this)
}, launch:Ext.emptyFn, useLoadMask:false, loadMaskFadeDuration:1000, loadMaskRemoveDuration:1050, autoInitViewport:true, dispatch:function (a) {
    return Ext.dispatch(a)
}, initLoadMask:function () {
    var c = this.useLoadMask, a = "loading-mask", b = typeof c == "string" ? c : a;
    if (c) {
        if (b == a) {
            Ext.getBody().createChild({id:a})
        }
        var e = Ext.get("loading-mask"), d = this.loadMaskFadeDuration, f = this.loadMaskRemoveDuration;
        Ext.defer(function () {
            e.addCls("fadeout");
            Ext.defer(function () {
                e.remove()
            }, f)
        }, d)
    }
}, onBeforeLaunch:function () {
    var d = Ext.History, c = d && this.useHistory, b = this.determineProfile(true);
    if (c) {
        this.historyForm = Ext.getBody().createChild({id:"history-form", cls:"x-hide-display", style:"display: none;", tag:"form", action:"#", children:[
            {tag:"div", children:[
                {tag:"input", id:d.fieldId, type:"hidden"},
                {tag:"iframe", id:d.iframeId}
            ]}
        ]});
        d.init();
        d.on("change", this.onHistoryChange, this);
        var a = d.getToken();
        if (this.launch.call(this.scope || this, b) !== false) {
            Ext.redirect(a || this.defaultUrl || {controller:"application", action:"index"})
        }
    } else {
        this.launch.call(this.scope || this, b)
    }
    this.launched = true;
    this.fireEvent("launch", this);
    if (this.setProfilesOnLaunch) {
        this.updateComponentProfiles(b)
    }
}, onReady:function () {
    if (this.useLoadMask) {
        this.initLoadMask()
    }
    Ext.EventManager.onOrientationChange(this.determineProfile, this);
    if (this.autoInitViewport) {
        Ext.Viewport.init(this.onBeforeLaunch, this)
    } else {
        this.onBeforeLaunch()
    }
    return this
}, determineProfile:function (b) {
    var d = this.currentProfile, a = this.profiles, c;
    for (c in a) {
        if (a[c]() === true) {
            if (c != d && this.fireEvent("beforeprofilechange", c, d) !== false) {
                if (this.autoUpdateComponentProfiles) {
                    this.updateComponentProfiles(c)
                }
                if (b !== true) {
                    this.fireEvent("profilechange", c, d)
                }
            }
            this.currentProfile = c;
            break
        }
    }
    return this.currentProfile
}, updateComponentProfiles:function (a) {
    Ext.ComponentMgr.each(function (c, b) {
        if (b.setProfile) {
            b.setProfile(a)
        }
    })
}, getProfile:function () {
    return this.currentProfile
}, onHistoryChange:function (a) {
    return Ext.redirect(a)
}});
Ext.ApplicationManager = new Ext.AbstractManager({register:function (c, b) {
    if (Ext.isObject(c)) {
        b = c
    } else {
        b.name = c
    }
    var a = new Ext.Application(b);
    this.all.add(a);
    this.currentApplication = a;
    return a
}});
Ext.regApplication = function () {
    return Ext.ApplicationManager.register.apply(Ext.ApplicationManager, arguments)
};
(function () {
    var c = Ext.Element = Ext.extend(Object, {defaultUnit:"px", constructor:function (d, e) {
        var f = typeof d == "string" ? document.getElementById(d) : d, g;
        if (!f) {
            return null
        }
        g = f.id;
        if (!e && g && Ext.cache[g]) {
            return Ext.cache[g].el
        }
        this.dom = f;
        this.id = g || Ext.id(f);
        return this
    }, set:function (h, e) {
        var f = this.dom, d, g;
        for (d in h) {
            if (h.hasOwnProperty(d)) {
                g = h[d];
                if (d == "style") {
                    this.applyStyles(g)
                } else {
                    if (d == "cls") {
                        f.className = g
                    } else {
                        if (e !== false) {
                            f.setAttribute(d, g)
                        } else {
                            f[d] = g
                        }
                    }
                }
            }
        }
        return this
    }, is:function (d) {
        return Ext.DomQuery.is(this.dom, d)
    }, getValue:function (d) {
        var e = this.dom.value;
        return d ? parseInt(e, 10) : e
    }, addListener:function (d, g, f, e) {
        Ext.EventManager.on(this.dom, d, g, f || this, e);
        return this
    }, removeListener:function (d, f, e) {
        Ext.EventManager.un(this.dom, d, f, e);
        return this
    }, removeAllListeners:function () {
        Ext.EventManager.removeAll(this.dom);
        return this
    }, purgeAllListeners:function () {
        Ext.EventManager.purgeElement(this, true);
        return this
    }, remove:function () {
        var d = this, e = d.dom;
        if (e) {
            delete d.dom;
            Ext.removeNode(e)
        }
    }, isAncestor:function (e) {
        var d = this.dom;
        e = Ext.getDom(e);
        if (d && e) {
            return d.contains(e)
        }
        return false
    }, isDescendent:function (d) {
        return Ext.fly(d, "_internal").isAncestor(this)
    }, contains:function (d) {
        return !d ? false : this.isAncestor(d)
    }, getAttribute:function (e, f) {
        var g = this.dom;
        return g.getAttributeNS(f, e) || g.getAttribute(f + ":" + e) || g.getAttribute(e) || g[e]
    }, setHTML:function (d) {
        if (this.dom) {
            this.dom.innerHTML = d
        }
        return this
    }, getHTML:function () {
        return this.dom ? this.dom.innerHTML : ""
    }, hide:function () {
        this.setVisible(false);
        return this
    }, show:function () {
        this.setVisible(true);
        return this
    }, setVisible:function (h, d) {
        var e = this, g = e.dom, f = this.getVisibilityMode();
        switch (f) {
            case c.VISIBILITY:
                this.removeCls(["x-hidden-display", "x-hidden-offsets"]);
                this[h ? "removeCls" : "addCls"]("x-hidden-visibility");
                break;
            case c.DISPLAY:
                this.removeCls(["x-hidden-visibility", "x-hidden-offsets"]);
                this[h ? "removeCls" : "addCls"]("x-hidden-display");
                break;
            case c.OFFSETS:
                this.removeCls(["x-hidden-visibility", "x-hidden-display"]);
                this[h ? "removeCls" : "addCls"]("x-hidden-offsets");
                break
        }
        return e
    }, getVisibilityMode:function () {
        var e = this.dom, d = c.data(e, "visibilityMode");
        if (d === undefined) {
            c.data(e, "visibilityMode", d = c.DISPLAY)
        }
        return d
    }, setVisibilityMode:function (d) {
        c.data(this.dom, "visibilityMode", d);
        return this
    }});
    var a = c.prototype;
    c.VISIBILITY = 1;
    c.DISPLAY = 2;
    c.OFFSETS = 3;
    c.addMethods = function (d) {
        Ext.apply(a, d)
    };
    a.on = a.addListener;
    a.un = a.removeListener;
    a.update = a.setHTML;
    c.get = function (d) {
        var g, f, h;
        if (!d) {
            return null
        }
        if (typeof d == "string") {
            if (!(f = document.getElementById(d))) {
                return null
            }
            if (Ext.cache[d] && Ext.cache[d].el) {
                g = Ext.cache[d].el;
                g.dom = f
            } else {
                g = c.addToCache(new c(f))
            }
            return g
        } else {
            if (d.tagName) {
                if (!(h = d.id)) {
                    h = Ext.id(d)
                }
                if (Ext.cache[h] && Ext.cache[h].el) {
                    g = Ext.cache[h].el;
                    g.dom = d
                } else {
                    g = c.addToCache(new c(d))
                }
                return g
            } else {
                if (d instanceof c) {
                    if (d != c.docEl) {
                        d.dom = document.getElementById(d.id) || d.dom
                    }
                    return d
                } else {
                    if (d.isComposite) {
                        return d
                    } else {
                        if (Ext.isArray(d)) {
                            return c.select(d)
                        } else {
                            if (d == document) {
                                if (!c.docEl) {
                                    var e = function () {
                                    };
                                    e.prototype = a;
                                    c.docEl = new e();
                                    c.docEl.dom = document;
                                    c.docEl.id = Ext.id(document)
                                }
                                return c.docEl
                            }
                        }
                    }
                }
            }
        }
        return null
    };
    c.addToCache = function (d, e) {
        e = e || d.id;
        Ext.cache[e] = {el:d, data:{}, events:{}};
        return d
    };
    c.data = function (e, d, f) {
        e = c.get(e);
        if (!e) {
            return null
        }
        var g = Ext.cache[e.id].data;
        if (arguments.length == 2) {
            return g[d]
        } else {
            return(g[d] = f)
        }
    };
    c.garbageCollect = function () {
        if (!Ext.enableGarbageCollector) {
            clearInterval(c.collectorThreadId)
        } else {
            var f, e, d = Ext.cache;
            for (f in d) {
                if (!d.hasOwnProperty(f)) {
                    continue
                }
                if (d[f].skipGarbageCollection) {
                    continue
                }
                e = d[f].el.dom;
                if (!e || !e.parentNode || (!e.offsetParent && !document.getElementById(f))) {
                    if (Ext.enableListenerCollection) {
                        Ext.EventManager.removeAll(e)
                    }
                    delete d[f]
                }
            }
        }
    };
    c.Flyweight = function (d) {
        this.dom = d
    };
    var b = function () {
    };
    b.prototype = a;
    c.Flyweight.prototype = new b;
    c.Flyweight.prototype.isFlyweight = true;
    c._flyweights = {};
    c.fly = function (f, d) {
        var e = null;
        d = d || "_global";
        f = Ext.getDom(f);
        if (f) {
            (c._flyweights[d] = c._flyweights[d] || new c.Flyweight()).dom = f;
            e = c._flyweights[d]
        }
        return e
    };
    Ext.get = c.get;
    Ext.fly = c.fly
})();
Ext.applyIf(Ext.Element, {unitRe:/\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i, camelRe:/(-[a-z])/gi, opacityRe:/alpha\(opacity=(.*)\)/i, propertyCache:{}, defaultUnit:"px", borders:{l:"border-left-width", r:"border-right-width", t:"border-top-width", b:"border-bottom-width"}, paddings:{l:"padding-left", r:"padding-right", t:"padding-top", b:"padding-bottom"}, margins:{l:"margin-left", r:"margin-right", t:"margin-top", b:"margin-bottom"}, addUnits:function (b, a) {
    if (b === "" || b == "auto" || b === null || b === undefined) {
        b = b || ""
    } else {
        if (!isNaN(b) || !this.unitRe.test(b)) {
            b = b + (a || this.defaultUnit || "px")
        }
    }
    return b
}, parseBox:function (b) {
    if (typeof b != "string") {
        b = b.toString()
    }
    var c = b.split(" "), a = c.length;
    if (a == 1) {
        c[1] = c[2] = c[3] = c[0]
    } else {
        if (a == 2) {
            c[2] = c[0];
            c[3] = c[1]
        } else {
            if (a == 3) {
                c[3] = c[1]
            }
        }
    }
    return{top:parseFloat(c[0]) || 0, right:parseFloat(c[1]) || 0, bottom:parseFloat(c[2]) || 0, left:parseFloat(c[3]) || 0}
}, unitizeBox:function (c, b) {
    var a = this.addUnits, d = this.parseBox(c);
    return a(d.top, b) + " " + a(d.right, b) + " " + a(d.bottom, b) + " " + a(d.left, b)
}, camelReplaceFn:function (b, c) {
    return c.charAt(1).toUpperCase()
}, normalize:function (a) {
    return this.propertyCache[a] || (this.propertyCache[a] = a == "float" ? "cssFloat" : a.replace(this.camelRe, this.camelReplaceFn))
}, getDocumentHeight:function () {
    return Math.max(!Ext.isStrict ? document.body.scrollHeight : document.documentElement.scrollHeight, this.getViewportHeight())
}, getDocumentWidth:function () {
    return Math.max(!Ext.isStrict ? document.body.scrollWidth : document.documentElement.scrollWidth, this.getViewportWidth())
}, getViewportHeight:function () {
    return window.innerHeight
}, getViewportWidth:function () {
    return window.innerWidth
}, getViewSize:function () {
    return{width:window.innerWidth, height:window.innerHeight}
}, getOrientation:function () {
    if (Ext.supports.OrientationChange) {
        return(window.orientation == 0) ? "portrait" : "landscape"
    }
    return(window.innerHeight > window.innerWidth) ? "portrait" : "landscape"
}, fromPoint:function (a, b) {
    return Ext.get(document.elementFromPoint(a, b))
}});
Ext.applyIf(Ext.Element, {getComputedTransformOffset:function (c) {
    if (c instanceof Ext.Element) {
        c = c.dom
    }
    var a = window.getComputedStyle(c).webkitTransform, b = a != "none" ? new WebKitCSSMatrix(a) : new WebKitCSSMatrix();
    if (typeof b.m41 != "undefined") {
        return new Ext.util.Offset(b.m41, b.m42)
    } else {
        if (typeof b.d != "undefined") {
            return new Ext.util.Offset(b.d, b.e)
        }
    }
    return new Ext.util.Offset(0, 0)
}, cssTransform:function (c, b) {
    if (c instanceof Ext.Element) {
        c = c.dom
    }
    var a = new WebKitCSSMatrix();
    Ext.iterate(b, function (e, d) {
        d = Ext.isArray(d) ? d : [d];
        a = a[e].apply(a, d)
    });
    if (Ext.supports.CSS3DTransform) {
        c.style.webkitTransform = "matrix3d(" + a.m11 + ", " + a.m12 + ", " + a.m13 + ", " + a.m14 + ", " + a.m21 + ", " + a.m22 + ", " + a.m23 + ", " + a.m24 + ", " + a.m31 + ", " + a.m32 + ", " + a.m33 + ", " + a.m34 + ", " + a.m41 + ", " + a.m42 + ", " + a.m43 + ", " + a.m44 + ")"
    } else {
        c.style.webkitTransform = a
    }
}, cssTranslate:function (a, b) {
    if (a instanceof Ext.Element) {
        a = a.dom
    }
    if (Ext.supports.CSS3DTransform) {
        a.style.webkitTransform = "translate3d(" + b.x + "px, " + b.y + "px, 0px)"
    } else {
        a.style.webkitTransform = "translate(" + b.x + "px, " + b.y + "px)"
    }
}});
Ext.Element.addMethods({getY:function (a) {
    return this.getXY(a)[1]
}, getX:function (a) {
    return this.getXY(a)[0]
}, getXY:function () {
    var a = window.webkitConvertPointFromNodeToPage(this.dom, new WebKitPoint(0, 0));
    return[a.x, a.y]
}, getOffsetsTo:function (a) {
    var c = this.getXY(), b = Ext.fly(a, "_internal").getXY();
    return[c[0] - b[0], c[1] - b[1]]
}, setXY:function (d) {
    var b = this;
    if (arguments.length > 1) {
        d = [d, arguments[1]]
    }
    var c = b.translatePoints(d), a = b.dom.style;
    for (d in c) {
        if (!c.hasOwnProperty(d)) {
            continue
        }
        if (!isNaN(c[d])) {
            a[d] = c[d] + "px"
        }
    }
    return b
}, setX:function (a) {
    return this.setXY([a, this.getY()])
}, setY:function (a) {
    return this.setXY([this.getX(), a])
}, setLeft:function (a) {
    this.setStyle("left", Ext.Element.addUnits(a));
    return this
}, setTop:function (a) {
    this.setStyle("top", Ext.Element.addUnits(a));
    return this
}, setTopLeft:function (c, b) {
    var a = Ext.Element.addUnits;
    this.setStyle("top", a(c));
    this.setStyle("left", a(b));
    return this
}, setRight:function (a) {
    this.setStyle("right", Ext.Element.addUnits(a));
    return this
}, setBottom:function (a) {
    this.setStyle("bottom", Ext.Element.addUnits(a));
    return this
}, getLeft:function (a) {
    return parseInt(this.getStyle("left"), 10) || 0
}, getRight:function (a) {
    return parseInt(this.getStyle("right"), 10) || 0
}, getTop:function (a) {
    return parseInt(this.getStyle("top"), 10) || 0
}, getBottom:function (a) {
    return parseInt(this.getStyle("bottom"), 10) || 0
}, setBox:function (d, c, b, a) {
    var e;
    if (Ext.isObject(d)) {
        b = d.width;
        a = d.height;
        c = d.top;
        d = d.left
    }
    if (d !== e) {
        this.setLeft(d)
    }
    if (c !== e) {
        this.setTop(c)
    }
    if (b !== e) {
        this.setWidth(b)
    }
    if (a !== e) {
        this.setHeight(a)
    }
    return this
}, getBox:function (g, j) {
    var h = this, e = h.dom, c = e.offsetWidth, k = e.offsetHeight, n, f, d, a, m, i;
    if (!j) {
        n = h.getXY()
    } else {
        if (g) {
            n = [0, 0]
        } else {
            n = [parseInt(h.getStyle("left"), 10) || 0, parseInt(h.getStyle("top"), 10) || 0]
        }
    }
    if (!g) {
        f = {x:n[0], y:n[1], 0:n[0], 1:n[1], width:c, height:k}
    } else {
        d = h.getBorderWidth.call(h, "l") + h.getPadding.call(h, "l");
        a = h.getBorderWidth.call(h, "r") + h.getPadding.call(h, "r");
        m = h.getBorderWidth.call(h, "t") + h.getPadding.call(h, "t");
        i = h.getBorderWidth.call(h, "b") + h.getPadding.call(h, "b");
        f = {x:n[0] + d, y:n[1] + m, 0:n[0] + d, 1:n[1] + m, width:c - (d + a), height:k - (m + i)}
    }
    f.left = f.x;
    f.top = f.y;
    f.right = f.x + f.width;
    f.bottom = f.y + f.height;
    return f
}, getPageBox:function (e) {
    var g = this, c = g.dom, j = c.offsetWidth, f = c.offsetHeight, m = g.getXY(), k = m[1], a = m[0] + j, i = m[1] + f, d = m[0];
    if (!c) {
        return new Ext.util.Region()
    }
    if (e) {
        return new Ext.util.Region(k, a, i, d)
    } else {
        return{left:d, top:k, width:j, height:f, right:a, bottom:i}
    }
}, translatePoints:function (a, g) {
    g = isNaN(a[1]) ? g : a[1];
    a = isNaN(a[0]) ? a : a[0];
    var d = this, e = d.isStyle("position", "relative"), f = d.getXY(), b = parseInt(d.getStyle("left"), 10), c = parseInt(d.getStyle("top"), 10);
    b = !isNaN(b) ? b : (e ? 0 : d.dom.offsetLeft);
    c = !isNaN(c) ? c : (e ? 0 : d.dom.offsetTop);
    return{left:(a - f[0] + b), top:(g - f[1] + c)}
}});
(function () {
    Ext.Element.classReCache = {};
    var b = Ext.Element, a = document.defaultView;
    b.addMethods({marginRightRe:/marginRight/i, trimRe:/^\s+|\s+$/g, spacesRe:/\s+/, addCls:function (g) {
        var h = this, f, c, e, d = [];
        if (!Ext.isArray(g)) {
            if (g && !this.hasCls(g)) {
                h.dom.className += " " + g
            }
        } else {
            for (f = 0, c = g.length; f < c; f++) {
                e = g[f];
                if (e && !h.hasCls(e)) {
                    d.push(e)
                }
            }
            if (d.length) {
                h.dom.className += " " + d.join(" ")
            }
        }
        return h
    }, addClass:function () {
        throw new Error("Component: addClass has been deprecated. Please use addCls.")
    }, removeCls:function (h) {
        var j = this, g, d, c, f, e;
        if (!Ext.isArray(h)) {
            h = [h]
        }
        if (j.dom && j.dom.className) {
            e = j.dom.className.replace(this.trimRe, "").split(this.spacesRe);
            for (g = 0, c = h.length; g < c; g++) {
                f = h[g];
                if (typeof f == "string") {
                    f = f.replace(this.trimRe, "");
                    d = e.indexOf(f);
                    if (d != -1) {
                        e.splice(d, 1)
                    }
                }
            }
            j.dom.className = e.join(" ")
        }
        return j
    }, removeClass:function () {
        throw new Error("Component: removeClass has been deprecated. Please use removeCls.")
    }, mask:function (d, f, i) {
        var g = this, e = g.dom, c = Ext.Element.data(e, "mask"), k, j, h = "";
        g.addCls("x-masked");
        if (g.getStyle("position") == "static") {
            g.addCls("x-masked-relative")
        }
        if (c) {
            c.remove()
        }
        if (Ext.isString(f) && !Ext.isEmpty(f)) {
            h = " " + f
        } else {
            if (f) {
                h = " x-mask-gray"
            }
        }
        k = g.createChild({cls:"x-mask" + ((i !== false) ? "" : " x-mask-gray"), html:d ? ('<div class="' + (f || "x-mask-message") + '">' + d + "</div>") : ""});
        j = g.getSize();
        Ext.Element.data(e, "mask", k);
        if (e === document.body) {
            j.height = window.innerHeight;
            if (g.orientationHandler) {
                Ext.EventManager.unOrientationChange(g.orientationHandler, g)
            }
            g.orientationHandler = function () {
                j = g.getSize();
                j.height = window.innerHeight;
                k.setSize(j)
            };
            Ext.EventManager.onOrientationChange(g.orientationHandler, g)
        }
        k.setSize(j);
        if (Ext.is.iPad) {
            Ext.repaint()
        }
    }, unmask:function () {
        var d = this, e = d.dom, c = Ext.Element.data(e, "mask");
        if (c) {
            c.remove();
            Ext.Element.data(e, "mask", undefined)
        }
        d.removeCls(["x-masked", "x-masked-relative"]);
        if (e === document.body) {
            Ext.EventManager.unOrientationChange(d.orientationHandler, d);
            delete d.orientationHandler
        }
    }, radioCls:function (f) {
        var g = this.dom.parentNode.childNodes, d;
        f = Ext.isArray(f) ? f : [f];
        for (var e = 0, c = g.length; e < c; e++) {
            d = g[e];
            if (d && d.nodeType == 1) {
                Ext.fly(d, "_internal").removeCls(f)
            }
        }
        return this.addCls(f)
    }, radioClass:function () {
        throw new Error("Component: radioClass has been deprecated. Please use radioCls.")
    }, toggleCls:function (c) {
        return this.hasCls(c) ? this.removeCls(c) : this.addCls(c)
    }, toggleClass:function () {
        throw new Error("Component: toggleClass has been deprecated. Please use toggleCls.")
    }, hasCls:function (c) {
        return c && (" " + this.dom.className + " ").indexOf(" " + c + " ") != -1
    }, hasClass:function () {
        throw new Error("Element: hasClass has been deprecated. Please use hasCls.");
        return this.hasCls.apply(this, arguments)
    }, replaceCls:function (d, c) {
        return this.removeCls(d).addCls(c)
    }, replaceClass:function () {
        throw new Error("Component: replaceClass has been deprecated. Please use replaceCls.")
    }, isStyle:function (c, d) {
        return this.getStyle(c) == d
    }, getStyle:function (i) {
        var h = this.dom, d, g, f, c = Ext.is, e = h.style;
        i = b.normalize(i);
        f = (a) ? a.getComputedStyle(h, "") : h.currentStyle;
        d = (f) ? f[i] : null;
        if (d && !c.correctRightMargin && this.marginRightRe.test(i) && e.position != "absolute" && d != "0px") {
            g = e.display;
            e.display = "inline-block";
            d = a.getComputedStyle(h, null)[i];
            e.display = g
        }
        d || (d = e[i]);
        if (!c.correctTransparentColor && d == "rgba(0, 0, 0, 0)") {
            d = "transparent"
        }
        return d
    }, setStyle:function (f, e) {
        var c, d;
        if (typeof f == "string") {
            c = {};
            c[f] = e;
            f = c
        }
        for (d in f) {
            if (f.hasOwnProperty(d)) {
                this.dom.style[b.normalize(d)] = f[d]
            }
        }
        return this
    }, applyStyles:function (e) {
        if (e) {
            var d, c, f = this.dom;
            if (typeof e == "function") {
                e = e.call()
            }
            if (typeof e == "string") {
                e = Ext.util.Format.trim(e).split(/\s*(?::|;)\s*/);
                for (d = 0, c = e.length; d < c;) {
                    f.style[b.normalize(e[d++])] = e[d++]
                }
            } else {
                if (typeof e == "object") {
                    this.setStyle(e)
                }
            }
        }
    }, getHeight:function (d) {
        var e = this.dom, c = d ? (e.clientHeight - this.getPadding("tb")) : e.offsetHeight;
        return c > 0 ? c : 0
    }, getWidth:function (c) {
        var e = this.dom, d = c ? (e.clientWidth - this.getPadding("lr")) : e.offsetWidth;
        return d > 0 ? d : 0
    }, setWidth:function (c) {
        var d = this;
        d.dom.style.width = b.addUnits(c);
        return d
    }, setHeight:function (c) {
        var d = this;
        d.dom.style.height = b.addUnits(c);
        return d
    }, setSize:function (e, c) {
        var f = this, d = f.dom.style;
        if (Ext.isObject(e)) {
            c = e.height;
            e = e.width
        }
        d.width = b.addUnits(e);
        d.height = b.addUnits(c);
        return f
    }, getBorderWidth:function (c) {
        return this.sumStyles(c, b.borders)
    }, getPadding:function (c) {
        return this.sumStyles(c, b.paddings)
    }, getMargin:function (c) {
        return this.sumStyles(c, b.margins)
    }, getViewSize:function () {
        var c = document, d = this.dom;
        if (d == c || d == c.body) {
            return{width:b.getViewportWidth(), height:b.getViewportHeight()}
        } else {
            return{width:d.clientWidth, height:d.clientHeight}
        }
    }, getSize:function (d) {
        var c = this.dom;
        return{width:Math.max(0, d ? (c.clientWidth - this.getPadding("lr")) : c.offsetWidth), height:Math.max(0, d ? (c.clientHeight - this.getPadding("tb")) : c.offsetHeight)}
    }, repaint:function () {
        var c = this.dom;
        this.addCls("x-repaint");
        c.style.background = "transparent none";
        setTimeout(function () {
            c.style.background = null;
            Ext.get(c).removeCls("x-repaint")
        }, 1);
        return this
    }, getOuterWidth:function () {
        return this.getWidth() + this.getMargin("lr")
    }, getOuterHeight:function () {
        return this.getHeight() + this.getMargin("tb")
    }, sumStyles:function (h, g) {
        var j = 0, d = h.match(/\w/g), c = d.length, f, e;
        for (e = 0; e < c; e++) {
            f = d[e] && parseFloat(this.getStyle(g[d[e]])) || 0;
            if (f) {
                j += Math.abs(f)
            }
        }
        return j
    }})
})();
Ext.Element.addMethods({findParent:function (h, g, c) {
    var e = this.dom, a = document.body, f = 0, d;
    g = g || 50;
    if (isNaN(g)) {
        d = Ext.getDom(g);
        g = Number.MAX_VALUE
    }
    while (e && e.nodeType == 1 && f < g && e != a && e != d) {
        if (Ext.DomQuery.is(e, h)) {
            return c ? Ext.get(e) : e
        }
        f++;
        e = e.parentNode
    }
    return null
}, findParentNode:function (d, c, a) {
    var b = Ext.fly(this.dom.parentNode, "_internal");
    return b ? b.findParent(d, c, a) : null
}, up:function (b, a) {
    return this.findParentNode(b, a, true)
}, select:function (a, b) {
    return Ext.Element.select(a, this.dom, b)
}, query:function (a) {
    return Ext.DomQuery.select(a, this.dom)
}, down:function (a, b) {
    var c = Ext.DomQuery.selectNode(a, this.dom);
    return b ? c : Ext.get(c)
}, child:function (a, b) {
    var d, c = this, e;
    e = Ext.get(c).id;
    e = e.replace(/[\.:]/g, "\\$0");
    d = Ext.DomQuery.selectNode("#" + e + " > " + a, c.dom);
    return b ? d : Ext.get(d)
}, parent:function (a, b) {
    return this.matchNode("parentNode", "parentNode", a, b)
}, next:function (a, b) {
    return this.matchNode("nextSibling", "nextSibling", a, b)
}, prev:function (a, b) {
    return this.matchNode("previousSibling", "previousSibling", a, b)
}, first:function (a, b) {
    return this.matchNode("nextSibling", "firstChild", a, b)
}, last:function (a, b) {
    return this.matchNode("previousSibling", "lastChild", a, b)
}, matchNode:function (b, e, a, c) {
    if (!this.dom) {
        return null
    }
    var d = this.dom[e];
    while (d) {
        if (d.nodeType == 1 && (!a || Ext.DomQuery.is(d, a))) {
            return !c ? Ext.get(d) : d
        }
        d = d[b]
    }
    return null
}});
Ext.Element.addMethods({getScrollParent:function () {
    var b = this.dom, a;
    while (b && b != document.body) {
        if (b.id && (a = Ext.ScrollManager.get(b.id))) {
            return a
        }
        b = b.parentNode
    }
    return null
}});
Ext.Element.addMethods({appendChild:function (a) {
    return Ext.get(a).appendTo(this)
}, appendTo:function (a) {
    Ext.getDom(a).appendChild(this.dom);
    return this
}, insertBefore:function (a) {
    a = Ext.getDom(a);
    a.parentNode.insertBefore(this.dom, a);
    return this
}, insertAfter:function (a) {
    a = Ext.getDom(a);
    a.parentNode.insertBefore(this.dom, a.nextSibling);
    return this
}, insertFirst:function (b, a) {
    b = b || {};
    if (b.nodeType || b.dom || typeof b == "string") {
        b = Ext.getDom(b);
        this.dom.insertBefore(b, this.dom.firstChild);
        return !a ? Ext.get(b) : b
    } else {
        return this.createChild(b, this.dom.firstChild, a)
    }
}, insertSibling:function (e, c, d) {
    var f = this, b, a = (c || "before").toLowerCase() == "after", g;
    if (Ext.isArray(e)) {
        g = f;
        Ext.each(e, function (h) {
            b = Ext.fly(g, "_internal").insertSibling(h, c, d);
            if (a) {
                g = b
            }
        });
        return b
    }
    e = e || {};
    if (e.nodeType || e.dom) {
        b = f.dom.parentNode.insertBefore(Ext.getDom(e), a ? f.dom.nextSibling : f.dom);
        if (!d) {
            b = Ext.get(b)
        }
    } else {
        if (a && !f.dom.nextSibling) {
            b = Ext.DomHelper.append(f.dom.parentNode, e, !d)
        } else {
            b = Ext.DomHelper[a ? "insertAfter" : "insertBefore"](f.dom, e, !d)
        }
    }
    return b
}, replace:function (a) {
    a = Ext.get(a);
    this.insertBefore(a);
    a.remove();
    return this
}, replaceWith:function (a) {
    var b = this;
    if (a.nodeType || a.dom || typeof a == "string") {
        a = Ext.get(a);
        b.dom.parentNode.insertBefore(a, b.dom)
    } else {
        a = Ext.DomHelper.insertBefore(b.dom, a)
    }
    delete Ext.cache[b.id];
    Ext.removeNode(b.dom);
    b.id = Ext.id(b.dom = a);
    Ext.Element.addToCache(b.isFlyweight ? new Ext.Element(b.dom) : b);
    return b
}, createChild:function (b, a, c) {
    b = b || {tag:"div"};
    if (a) {
        return Ext.DomHelper.insertBefore(a, b, c !== true)
    } else {
        return Ext.DomHelper[!this.dom.firstChild ? "overwrite" : "append"](this.dom, b, c !== true)
    }
}, wrap:function (a, b) {
    var c = Ext.DomHelper.insertBefore(this.dom, a || {tag:"div"}, !b);
    c.dom ? c.dom.appendChild(this.dom) : c.appendChild(this.dom);
    return c
}, insertHtml:function (b, c, a) {
    var d = Ext.DomHelper.insertHtml(b, this.dom, c);
    return a ? Ext.get(d) : d
}});
Ext.Element.addMethods({getAnchorXY:function (f, j, m) {
    f = (f || "tl").toLowerCase();
    m = m || {};
    var i = this, a = i.dom == document.body || i.dom == document, b = m.width || a ? window.innerWidth : i.getWidth(), k = m.height || a ? window.innerHeight : i.getHeight(), l, c = Math.round, d = i.getXY(), h = a ? 0 : !j ? d[0] : 0, g = a ? 0 : !j ? d[1] : 0, e = {c:[c(b * 0.5), c(k * 0.5)], t:[c(b * 0.5), 0], l:[0, c(k * 0.5)], r:[b, c(k * 0.5)], b:[c(b * 0.5), k], tl:[0, 0], bl:[0, k], br:[b, k], tr:[b, 0]};
    l = e[f];
    return[l[0] + h, l[1] + g]
}, getAlignToXY:function (e, w, h) {
    e = Ext.get(e);
    if (!e || !e.dom) {
        throw new Error("Element.alignToXY with an element that doesn't exist")
    }
    h = h || [0, 0];
    if (!w || w == "?") {
        w = "tl-bl?"
    } else {
        if (!(/-/).test(w) && w !== "") {
            w = "tl-" + w
        }
    }
    w = w.toLowerCase();
    var u = this, d = w.match(/^([a-z]+)-([a-z]+)(\?)?$/), m = window.innerWidth, t = window.innerHeight, c = "", a = "", z, v, l, k, p, n, f, b, j, i, q, o, g, s;
    if (!d) {
        throw"Element.alignTo with an invalid alignment " + w
    }
    c = d[1];
    a = d[2];
    s = !!d[3];
    z = u.getAnchorXY(c, true);
    v = e.getAnchorXY(a, false);
    l = v[0] - z[0] + h[0];
    k = v[1] - z[1] + h[1];
    if (s) {
        q = u.getWidth();
        o = u.getHeight();
        g = e.getPageBox();
        b = c.charAt(0);
        f = c.charAt(c.length - 1);
        i = a.charAt(0);
        j = a.charAt(a.length - 1);
        n = ((b == "t" && i == "b") || (b == "b" && i == "t"));
        p = ((f == "r" && j == "l") || (f == "l" && j == "r"));
        if (l + q > m) {
            l = p ? g.left - q : m - q
        }
        if (l < 0) {
            l = p ? g.right : 0
        }
        if (k + o > t) {
            k = n ? g.top - o : t - o
        }
        if (k < 0) {
            k = n ? g.bottom : 0
        }
    }
    return[l, k]
}});
Ext.CompositeElement = function (b, a) {
    this.elements = [];
    this.add(b, a);
    this.el = new Ext.Element.Flyweight()
};
Ext.CompositeElement.prototype = {isComposite:true, getElement:function (a) {
    var b = this.el;
    b.dom = a;
    b.id = a.id;
    return b
}, transformElement:function (a) {
    return Ext.getDom(a)
}, getCount:function () {
    return this.elements.length
}, add:function (d, b) {
    var e = this, f = e.elements;
    if (!d) {
        return this
    }
    if (typeof d == "string") {
        d = Ext.Element.selectorFunction(d, b)
    } else {
        if (d.isComposite) {
            d = d.elements
        } else {
            if (!Ext.isIterable(d)) {
                d = [d]
            }
        }
    }
    for (var c = 0, a = d.length; c < a; ++c) {
        f.push(e.transformElement(d[c]))
    }
    return e
}, invoke:function (f, b) {
    var g = this, d = g.elements, a = d.length, h, c;
    for (c = 0; c < a; c++) {
        h = d[c];
        if (h) {
            Ext.Element.prototype[f].apply(g.getElement(h), b)
        }
    }
    return g
}, item:function (b) {
    var d = this, c = d.elements[b], a = null;
    if (c) {
        a = d.getElement(c)
    }
    return a
}, addListener:function (b, h, g, f) {
    var d = this.elements, a = d.length, c, j;
    for (c = 0; c < a; c++) {
        j = d[c];
        if (j) {
            Ext.EventManager.on(j, b, h, g || j, f)
        }
    }
    return this
}, each:function (f, d) {
    var g = this, c = g.elements, a = c.length, b, h;
    for (b = 0; b < a; b++) {
        h = c[b];
        if (h) {
            h = this.getElement(h);
            if (f.call(d || h, h, g, b)) {
                break
            }
        }
    }
    return g
}, fill:function (a) {
    var b = this;
    b.elements = [];
    b.add(a);
    return b
}, filter:function (a) {
    var b = [], d = this, e = d.elements, c = Ext.isFunction(a) ? a : function (f) {
        return f.is(a)
    };
    d.each(function (h, f, g) {
        if (c(h, g) !== false) {
            b[b.length] = d.transformElement(h)
        }
    });
    d.elements = b;
    return d
}, first:function () {
    return this.item(0)
}, last:function () {
    return this.item(this.getCount() - 1)
}, contains:function (a) {
    return this.indexOf(a) != -1
}, indexOf:function (a) {
    return this.elements.indexOf(this.transformElement(a))
}, clear:function () {
    this.elements = []
}};
Ext.CompositeElement.prototype.on = Ext.CompositeElement.prototype.addListener;
(function () {
    var c, b = Ext.Element.prototype, a = Ext.CompositeElement.prototype;
    for (c in b) {
        if (Ext.isFunction(b[c])) {
            (function (d) {
                a[d] = a[d] || function () {
                    return this.invoke(d, arguments)
                }
            }).call(a, c)
        }
    }
})();
if (Ext.DomQuery) {
    Ext.Element.selectorFunction = Ext.DomQuery.select
}
Ext.Element.select = function (a, b, d) {
    var c;
    d = (d === false) ? false : true;
    if (typeof a == "string") {
        c = Ext.Element.selectorFunction(a, b)
    } else {
        if (a.length !== undefined) {
            c = a
        } else {
            throw new Error("Invalid selector")
        }
    }
    return d ? new Ext.CompositeElement(c) : c
};
Ext.select = Ext.Element.select;
Ext.CompositeElementLite = Ext.CompositeElement;
Ext.apply(Ext.CompositeElementLite.prototype, {addElements:function (c, a) {
    if (!c) {
        return this
    }
    if (typeof c == "string") {
        c = Ext.Element.selectorFunction(c, a)
    }
    var b = this.elements;
    Ext.each(c, function (d) {
        b.push(Ext.get(d))
    });
    return this
}, removeElement:function (d, e) {
    var c = this, a = this.elements, b;
    Ext.each(d, function (f) {
        if ((b = (a[f] || a[f = c.indexOf(f)]))) {
            if (e) {
                if (b.dom) {
                    b.remove()
                } else {
                    Ext.removeNode(b)
                }
            }
            a.splice(f, 1)
        }
    });
    return this
}, replaceElement:function (e, c, a) {
    var b = !isNaN(e) ? e : this.indexOf(e), f;
    if (b > -1) {
        c = Ext.getDom(c);
        if (a) {
            f = this.elements[b];
            f.parentNode.insertBefore(c, f);
            Ext.removeNode(f)
        }
        this.elements.splice(b, 1, c)
    }
    return this
}});
Ext.DomHelper = {emptyTags:/^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i, confRe:/tag|children|cn|html$/i, endRe:/end/i, markup:function (h) {
    var d = "", c, g, f, a, j;
    if (typeof h == "string") {
        d = h
    } else {
        if (Ext.isArray(h)) {
            for (var e = 0; e < h.length; e++) {
                if (h[e]) {
                    d += this.markup(h[e])
                }
            }
        } else {
            d += "<" + (h.tag = h.tag || "div");
            for (c in h) {
                if (!h.hasOwnProperty(c)) {
                    continue
                }
                g = h[c];
                if (!this.confRe.test(c)) {
                    if (typeof g == "object") {
                        d += " " + c + '="';
                        for (f in g) {
                            if (!g.hasOwnProperty(f)) {
                                continue
                            }
                            d += f + ":" + g[f] + ";"
                        }
                        d += '"'
                    } else {
                        d += " " + ({cls:"class", htmlFor:"for"}[c] || c) + '="' + g + '"'
                    }
                }
            }
            if (this.emptyTags.test(h.tag)) {
                d += "/>"
            } else {
                d += ">";
                if ((j = h.children || h.cn)) {
                    d += this.markup(j)
                } else {
                    if (h.html) {
                        d += h.html
                    }
                }
                d += "</" + h.tag + ">"
            }
        }
    }
    return d
}, applyStyles:function (d, e) {
    if (e) {
        var b = 0, a, c;
        d = Ext.fly(d);
        if (typeof e == "function") {
            e = e.call()
        }
        if (typeof e == "string") {
            e = Ext.util.Format.trim(e).split(/\s*(?::|;)\s*/);
            for (a = e.length; b < a;) {
                d.setStyle(e[b++], e[b++])
            }
        } else {
            if (Ext.isObject(e)) {
                d.setStyle(e)
            }
        }
    }
}, insertHtml:function (f, a, g) {
    var e = {}, c, i, h, j, d, b;
    f = f.toLowerCase();
    e.beforebegin = ["BeforeBegin", "previousSibling"];
    e.afterend = ["AfterEnd", "nextSibling"];
    h = a.ownerDocument.createRange();
    i = "setStart" + (this.endRe.test(f) ? "After" : "Before");
    if (e[f]) {
        h[i](a);
        j = h.createContextualFragment(g);
        a.parentNode.insertBefore(j, f == "beforebegin" ? a : a.nextSibling);
        return a[(f == "beforebegin" ? "previous" : "next") + "Sibling"]
    } else {
        d = (f == "afterbegin" ? "first" : "last") + "Child";
        if (a.firstChild) {
            h[i](a[d]);
            j = h.createContextualFragment(g);
            if (f == "afterbegin") {
                a.insertBefore(j, a.firstChild)
            } else {
                a.appendChild(j)
            }
        } else {
            a.innerHTML = g
        }
        return a[d]
    }
    throw'Illegal insertion point -> "' + f + '"'
}, insertBefore:function (a, c, b) {
    return this.doInsert(a, c, b, "beforebegin")
}, insertAfter:function (a, c, b) {
    return this.doInsert(a, c, b, "afterend", "nextSibling")
}, insertFirst:function (a, c, b) {
    return this.doInsert(a, c, b, "afterbegin", "firstChild")
}, append:function (a, c, b) {
    return this.doInsert(a, c, b, "beforeend", "", true)
}, overwrite:function (a, c, b) {
    a = Ext.getDom(a);
    a.innerHTML = this.markup(c);
    return b ? Ext.get(a.firstChild) : a.firstChild
}, doInsert:function (d, f, e, g, c, a) {
    var b = this.insertHtml(g, Ext.getDom(d), this.markup(f));
    return e ? Ext.get(b, true) : b
}};
Ext.DomQuery = {select:function (h, b) {
    var g = [], d, f, e, c, a;
    b = b || document;
    if (typeof b == "string") {
        b = document.getElementById(b)
    }
    h = h.split(",");
    for (f = 0, c = h.length; f < c; f++) {
        if (typeof h[f] == "string") {
            d = b.querySelectorAll(h[f]);
            for (e = 0, a = d.length; e < a; e++) {
                g.push(d[e])
            }
        }
    }
    return g
}, selectNode:function (b, a) {
    return Ext.DomQuery.select(b, a)[0]
}, is:function (a, b) {
    if (typeof a == "string") {
        a = document.getElementById(a)
    }
    return Ext.DomQuery.select(b).indexOf(a) !== -1
}};
Ext.Element.selectorFunction = Ext.DomQuery.select;
Ext.query = Ext.DomQuery.select;
Ext.Anim = Ext.extend(Object, {isAnim:true, disableAnimations:false, defaultConfig:{from:{}, to:{}, duration:250, delay:0, easing:"ease-in-out", autoClear:true, out:true, direction:null, reverse:false}, opposites:{left:"right", right:"left", up:"down", down:"up"}, constructor:function (a) {
    a = Ext.apply({}, a || {}, this.defaultConfig);
    this.config = a;
    Ext.Anim.superclass.constructor.call(this);
    this.running = {}
}, initConfig:function (c, b) {
    var e = this, d = {}, a = Ext.apply({}, b || {}, e.config);
    a.el = c = Ext.get(c);
    if (a.reverse && e.opposites[a.direction]) {
        a.direction = e.opposites[a.direction]
    }
    if (e.config.before) {
        e.config.before.call(a, c, a)
    }
    if (b.before) {
        b.before.call(a.scope || a, c, a)
    }
    return a
}, run:function (c, a) {
    c = Ext.get(c);
    a = a || {};
    var d = this, b = c.dom.style, e, f = a.after;
    if (d.running[c.id]) {
        d.onTransitionEnd(null, c, {config:a, after:f})
    }
    a = this.initConfig(c, a);
    if (this.disableAnimations) {
        for (e in a.to) {
            if (!a.to.hasOwnProperty(e)) {
                continue
            }
            b[e] = a.to[e]
        }
        this.onTransitionEnd(null, c, {config:a, after:f});
        return d
    }
    c.un("webkitTransitionEnd", d.onTransitionEnd, d);
    b.webkitTransitionDuration = "0ms";
    for (e in a.from) {
        if (!a.from.hasOwnProperty(e)) {
            continue
        }
        b[e] = a.from[e]
    }
    setTimeout(function () {
        if (!c.dom) {
            return
        }
        if (a.is3d === true) {
            c.parent().setStyle({"-webkit-perspective":"1200", "-webkit-transform-style":"preserve-3d"})
        }
        b.webkitTransitionDuration = a.duration + "ms";
        b.webkitTransitionProperty = "all";
        b.webkitTransitionTimingFunction = a.easing;
        c.on("webkitTransitionEnd", d.onTransitionEnd, d, {config:a, after:f});
        for (e in a.to) {
            if (!a.to.hasOwnProperty(e)) {
                continue
            }
            b[e] = a.to[e]
        }
    }, a.delay || 5);
    d.running[c.id] = a;
    return d
}, onTransitionEnd:function (e, c, g) {
    c = Ext.get(c);
    if (this.running[c.id] === undefined) {
        return
    }
    var b = c.dom.style, a = g.config, f, d = this;
    c.un("webkitTransitionEnd", d.onTransitionEnd, d);
    if (a.autoClear) {
        for (f in a.to) {
            if (!a.to.hasOwnProperty(f)) {
                continue
            }
            b[f] = ""
        }
    }
    b.webkitTransitionDuration = null;
    b.webkitTransitionProperty = null;
    b.webkitTransitionTimingFunction = null;
    if (a.is3d) {
        c.parent().setStyle({"-webkit-perspective":"", "-webkit-transform-style":""})
    }
    if (d.config.after) {
        d.config.after.call(a, c, a)
    }
    if (g.after) {
        g.after.call(a.scope || d, c, a)
    }
    delete d.running[c.id]
}});
Ext.Anim.seed = 1000;
Ext.Anim.run = function (b, c, a) {
    if (b.isComponent) {
        b = b.el
    }
    a = a || {};
    if (c.isAnim) {
        c.run(b, a)
    } else {
        if (Ext.isObject(c)) {
            if (a.before && c.before) {
                a.before = Ext.createInterceptor(a.before, c.before, c.scope)
            }
            if (a.after && c.after) {
                a.after = Ext.createInterceptor(a.after, c.after, c.scope)
            }
            a = Ext.apply({}, a, c);
            c = c.type
        }
        if (!Ext.anims[c]) {
            throw c + " is not a valid animation type."
        } else {
            if (b && b.dom) {
                Ext.anims[c].run(b, a)
            }
        }
    }
};
Ext.anims = {fade:new Ext.Anim({before:function (b) {
    var c = 1, a = 1, e = b.getStyle("z-index") == "auto" ? 0 : b.getStyle("z-index"), d = e;
    if (this.out) {
        a = 0
    } else {
        d = e + 1;
        c = 0
    }
    this.from = {opacity:c, "z-index":d};
    this.to = {opacity:a, "z-index":d}
}}), slide:new Ext.Anim({direction:"left", cover:false, reveal:false, before:function (b) {
    var a = b.getStyle("z-index") == "auto" ? 0 : b.getStyle("z-index"), e = a + 1, h = 0, f = 0, i = 0, g = 0, c = b.getHeight(), d = b.getWidth();
    if (this.direction == "left" || this.direction == "right") {
        if (this.out == true) {
            h = -d
        } else {
            i = d
        }
    } else {
        if (this.direction == "up" || this.direction == "down") {
            if (this.out == true) {
                f = -c
            } else {
                g = c
            }
        }
    }
    if (this.direction == "right" || this.direction == "down") {
        f *= -1;
        h *= -1;
        g *= -1;
        i *= -1
    }
    if (this.cover && this.out) {
        h = 0;
        f = 0;
        e = a
    } else {
        if (this.reveal && !this.out) {
            i = 0;
            g = 0;
            e = a
        }
    }
    this.from = {"-webkit-transform":"translate3d(" + i + "px, " + g + "px, 0)", "z-index":e, opacity:0.99};
    this.to = {"-webkit-transform":"translate3d(" + h + "px, " + f + "px, 0)", "z-index":e, opacity:1}
}}), pop:new Ext.Anim({scaleOnExit:true, before:function (d) {
    var b = 1, c = 1, g = 1, a = 1, h = d.getStyle("z-index") == "auto" ? 0 : d.getStyle("z-index"), f = h, e = h;
    if (!this.out) {
        b = 0.01;
        f = h + 1;
        e = h + 1;
        g = 0
    } else {
        if (this.scaleOnExit) {
            c = 0.01;
            a = 0
        } else {
            a = 0.8
        }
    }
    this.from = {"-webkit-transform":"scale(" + b + ")", "-webkit-transform-origin":"50% 50%", opacity:g, "z-index":f};
    this.to = {"-webkit-transform":"scale(" + c + ")", "-webkit-transform-origin":"50% 50%", opacity:a, "z-index":e}
}})};
Ext.apply(Ext.anims, {flip:new Ext.Anim({is3d:true, direction:"left", before:function (c) {
    var f = "Y", a = 1, b = 1, e = 0, d = 0;
    if (this.out) {
        d = -180;
        b = 0.8
    } else {
        e = 180;
        a = 0.8
    }
    if (this.direction == "up" || this.direction == "down") {
        f = "X"
    }
    if (this.direction == "right" || this.direction == "left") {
        d *= -1;
        e *= -1
    }
    this.from = {"-webkit-transform":"rotate" + f + "(" + e + "deg) scale(" + a + ")", "-webkit-backface-visibility":"hidden"};
    this.to = {"-webkit-transform":"rotate" + f + "(" + d + "deg) scale(" + b + ")", "-webkit-backface-visibility":"hidden"}
}}), cube:new Ext.Anim({is3d:true, direction:"left", style:"outer", before:function (b) {
    var n = "0% 0%", o = 0, a = 0, k = "Y", h = 0, i = 0, l = 1, e = 1, g, f = b.getWidth(), d = b.getHeight(), m = true, c = " translateX(0)", j = "";
    if (this.direction == "left" || this.direction == "right") {
        if (this.out) {
            n = "100% 100%";
            i = f;
            e = 0.5;
            a = -90
        } else {
            n = "0% 0%";
            h = f;
            l = 0.5;
            o = 90
        }
    } else {
        if (this.direction == "up" || this.direction == "down") {
            k = "X";
            if (this.out) {
                n = "100% 100%";
                i = d;
                a = 90
            } else {
                n = "0% 0%";
                h = d;
                o = -90
            }
        }
    }
    if (this.direction == "down" || this.direction == "right") {
        o *= -1;
        a *= -1;
        n = (n == "0% 0%") ? "100% 100%" : "0% 0%"
    }
    if (this.style == "inner") {
        h *= -1;
        i *= -1;
        o *= -1;
        a *= -1;
        if (!this.out) {
            j = " translateX(0px)";
            n = "0% 50%"
        } else {
            j = c;
            n = "100% 50%"
        }
    }
    this.from = {"-webkit-transform":"rotate" + k + "(" + o + "deg)" + (m ? " translateZ(" + h + "px)" : "") + c, "-webkit-transform-origin":n};
    this.to = {"-webkit-transform":"rotate" + k + "(" + a + "deg) translateZ(" + i + "px)" + j, "-webkit-transform-origin":n}
}, duration:250}), wipe:new Ext.Anim({before:function (d) {
    var e = d.getStyle("z-index"), a = "", b = "100%", c = "100%";
    if (!this.out) {
        zIndex = e + 1;
        a = "-webkit-gradient(linear, left bottom, right bottom, from(transparent), to(#000), color-stop(66%, #000), color-stop(33%, transparent))";
        b = d.getHeight() * 100 + "px";
        c = d.getHeight();
        this.from = {"-webkit-mask-image":a, "-webkit-mask-size":d.getWidth() * 3 + "px " + d.getHeight() + "px", "z-index":zIndex, "-webkit-mask-position-x":0};
        this.to = {"-webkit-mask-image":a, "-webkit-mask-size":d.getWidth() * 3 + "px " + d.getHeight() + "px", "z-index":zIndex, "-webkit-mask-position-x":-d.getWidth() * 2 + "px"}
    }
}, duration:500})});
Ext.apply(Ext, {version:"1.1.1", versionDetail:{major:1, minor:1, patch:1}, setup:function (a) {
    if (a && typeof a == "object") {
        if (a.addMetaTags !== false) {
            this.addMetaTags(a)
        }
        if (Ext.isFunction(a.onReady)) {
            var b = this;
            Ext.onReady(function () {
                var c = arguments;
                if (a.fullscreen !== false) {
                    Ext.Viewport.init(function () {
                        a.onReady.apply(b, c)
                    })
                } else {
                    a.onReady.apply(this, c)
                }
            }, a.scope)
        }
    }
}, getDom:function (a) {
    if (!a || !document) {
        return null
    }
    return a.dom ? a.dom : (typeof a == "string" ? document.getElementById(a) : a)
}, removeNode:function (a) {
    if (a && a.parentNode && a.tagName != "BODY") {
        Ext.EventManager.removeAll(a);
        a.parentNode.removeChild(a);
        delete Ext.cache[a.id]
    }
}, addMetaTags:function (b) {
    if (!Ext.isObject(b)) {
        return
    }
    var c = Ext.get(document.getElementsByTagName("head")[0]), a, d;
    if (!Ext.is.Desktop) {
        a = Ext.get(document.createElement("meta"));
        a.set({name:"viewport", content:"width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0;"});
        c.appendChild(a)
    }
    if (Ext.is.iOS) {
        if (b.fullscreen !== false) {
            a = Ext.get(document.createElement("meta"));
            a.set({name:"apple-mobile-web-app-capable", content:"yes"});
            c.appendChild(a);
            if (Ext.isString(b.statusBarStyle)) {
                a = Ext.get(document.createElement("meta"));
                a.set({name:"apple-mobile-web-app-status-bar-style", content:b.statusBarStyle});
                c.appendChild(a)
            }
        }
        if (b.tabletStartupScreen && Ext.is.iPad) {
            a = Ext.get(document.createElement("link"));
            a.set({rel:"apple-touch-startup-image", href:b.tabletStartupScreen});
            c.appendChild(a)
        }
        if (b.phoneStartupScreen && !Ext.is.iPad) {
            a = Ext.get(document.createElement("link"));
            a.set({rel:"apple-touch-startup-image", href:b.phoneStartupScreen});
            c.appendChild(a)
        }
        if (b.icon) {
            b.phoneIcon = b.tabletIcon = b.icon
        }
        d = (b.glossOnIcon === false) ? "-precomposed" : "";
        if (Ext.is.iPad && Ext.isString(b.tabletIcon)) {
            a = Ext.get(document.createElement("link"));
            a.set({rel:"apple-touch-icon" + d, href:b.tabletIcon});
            c.appendChild(a)
        } else {
            if (!Ext.is.iPad && Ext.isString(b.phoneIcon)) {
                a = Ext.get(document.createElement("link"));
                a.set({rel:"apple-touch-icon" + d, href:b.phoneIcon});
                c.appendChild(a)
            }
        }
    }
}});
(function () {
    var a = function () {
        var c = Ext.getBody(), b = [];
        if (!c) {
            return false
        }
        var d = Ext.is;
        if (d.Phone) {
            b.push("x-phone")
        } else {
            if (d.Tablet) {
                b.push("x-tablet")
            } else {
                if (d.Desktop) {
                    b.push("x-desktop")
                }
            }
        }
        if (d.iPad) {
            b.push("x-ipad")
        }
        if (d.iOS) {
            b.push("x-ios")
        }
        if (d.Android) {
            b.push("x-android", "x-android-" + d.AndroidMajorVersion)
        }
        if (d.Blackberry) {
            b.push("x-bb")
        }
        if (d.Standalone) {
            b.push("x-standalone")
        }
        if (b.length) {
            c.addCls(b)
        }
        return true
    };
    if (!a()) {
        Ext.onReady(a)
    }
})();
Ext.Viewport = new (Ext.extend(Ext.util.Observable, {constructor:function () {
    var a = this;
    this.addEvents("orientationchange", "resize");
    this.stretchSizes = {};
    if (Ext.supports.OrientationChange) {
        window.addEventListener("orientationchange", Ext.createDelegate(a.onOrientationChange, a), false)
    } else {
        window.addEventListener("resize", Ext.createDelegate(a.onResize, a), false)
    }
    if (!Ext.desktop) {
        document.addEventListener("touchstart", Ext.createDelegate(a.onTouchStartCapturing, a), true)
    }
}, init:function (c, b) {
    var d = this, e = Math.max(window.innerHeight, window.innerWidth) * 2, a = Ext.getBody();
    d.updateOrientation();
    this.initialHeight = window.innerHeight;
    this.initialOrientation = this.orientation;
    a.setHeight(e);
    Ext.gesture.Manager.freeze();
    this.scrollToTop();
    setTimeout(function () {
        d.scrollToTop();
        setTimeout(function () {
            d.scrollToTop();
            d.initialHeight = Math.max(d.initialHeight, window.innerHeight);
            if (c) {
                c.apply(b || window)
            }
            d.updateBodySize();
            Ext.gesture.Manager.thaw()
        }, 500)
    }, 500)
}, scrollToTop:function () {
    if (Ext.is.iOS) {
        if (Ext.is.Phone) {
            document.body.scrollTop = document.body.scrollHeight
        }
    } else {
        if (Ext.is.Blackberry) {
            window.scrollTo(0, 1000)
        } else {
            window.scrollTo(0, 1)
        }
    }
}, updateBodySize:function () {
    Ext.getBody().setSize(window.innerWidth, window.innerHeight)
}, updateOrientation:function () {
    this.lastSize = this.getSize();
    this.orientation = this.getOrientation()
}, onTouchStartCapturing:function (a) {
    if (!Ext.currentlyFocusedField && Ext.is.iOS) {
        this.scrollToTop()
    }
}, onOrientationChange:function () {
    var b = this, a = Ext.getBody();
    if (!Ext.is.Phone) {
        a.setHeight(a.getWidth());
        this.updateOrientation();
        this.fireEvent("orientationchange", this, this.orientation);
        b.scrollToTop();
        b.updateBodySize();
        b.fireResizeEvent();
        Ext.repaint();
        return
    }
    Ext.gesture.Manager.freeze();
    a.setHeight(a.getWidth());
    this.updateOrientation();
    this.fireEvent("orientationchange", this, this.orientation);
    setTimeout(function () {
        b.scrollToTop();
        setTimeout(function () {
            b.updateBodySize();
            b.fireResizeEvent();
            Ext.gesture.Manager.thaw();
            Ext.repaint()
        }, 200)
    }, 200)
}, fireResizeEvent:function () {
    var a = this;
    if (!Ext.is.iOS) {
        if (this.resizeEventTimer) {
            clearTimeout(this.resizeEventTimer)
        }
        this.resizeEventTimer = setTimeout(function () {
            a.fireEvent("resize", a, a.getSize())
        }, 500)
    } else {
        a.fireEvent("resize", a, a.getSize())
    }
}, onResize:function () {
    if (this.orientation != this.getOrientation()) {
        this.onOrientationChange()
    } else {
        var a = this.getSize();
        if (!Ext.is.iOS && !Ext.is.Desktop) {
            if ((a.width == this.lastSize.width && a.height > this.lastSize.height) || (a.height == this.lastSize.height && a.width > this.lastSize.width)) {
                this.fireEvent("resize", this, a)
            }
        } else {
            this.fireEvent("resize", this, a)
        }
    }
}, getSize:function () {
    var a = {width:window.innerWidth, height:window.innerHeight};
    if (!Ext.is.Desktop) {
        a.height = (this.orientation == this.initialOrientation) ? Math.max(this.initialHeight, a.height) : a.height
    }
    return a
}, getOffset:function () {
    return{x:window.pageXOffset, y:window.pageYOffset}
}, getOrientation:function () {
    var d = this, b = d.getSize(), c, a;
    if (window.hasOwnProperty("orientation")) {
        a = window.orientation;
        c = Ext.is.Android && Ext.is.AndroidMajorVersion === 3;
        if (a % 180 === 0) {
            return c ? "landscape" : "portrait"
        } else {
            return c ? "portrait" : "landscape"
        }
    } else {
        if (!Ext.is.iOS && !Ext.is.Desktop) {
            if ((b.width == d.lastSize.width && b.height < d.lastSize.height) || (b.height == d.lastSize.height && b.width < d.lastSize.width)) {
                return d.orientation
            }
        }
        return(window.innerHeight > window.innerWidth) ? "portrait" : "landscape"
    }
}}));
Ext.util.TapRepeater = Ext.extend(Ext.util.Observable, {constructor:function (b, a) {
    this.el = Ext.get(b);
    Ext.apply(this, a);
    this.addEvents("touchstart", "tap", "touchend");
    this.el.on({touchstart:this.onTouchStart, touchend:this.onTouchEnd, scope:this});
    if (this.preventDefault || this.stopDefault) {
        this.el.on("tap", this.eventOptions, this)
    }
    Ext.util.TapRepeater.superclass.constructor.call(this)
}, interval:10, delay:250, preventDefault:true, stopDefault:false, timer:0, eventOptions:function (a) {
    if (this.preventDefault) {
        a.preventDefault()
    }
    if (this.stopDefault) {
        a.stopEvent()
    }
}, destroy:function () {
    Ext.destroy(this.el);
    this.clearListeners()
}, onTouchStart:function (a) {
    clearTimeout(this.timer);
    if (this.pressClass) {
        this.el.addCls(this.pressClass)
    }
    this.tapStartTime = new Date();
    this.fireEvent("touchstart", this, a);
    this.fireEvent("tap", this, a);
    if (this.accelerate) {
        this.delay = 400
    }
    this.timer = Ext.defer(this.tap, this.delay || this.interval, this, [a])
}, tap:function (a) {
    this.fireEvent("tap", this, a);
    this.timer = Ext.defer(this.tap, this.accelerate ? this.easeOutExpo(Ext.util.Date.getElapsed(this.tapStartTime), 400, -390, 12000) : this.interval, this, [a])
}, easeOutExpo:function (e, a, g, f) {
    return(e == f) ? a + g : g * (-Math.pow(2, -10 * e / f) + 1) + a
}, onTouchEnd:function (a) {
    clearTimeout(this.timer);
    this.el.removeCls(this.pressClass);
    this.fireEvent("touchend", this, a)
}});
if (!this.JSON) {
    this.JSON = {}
}
(function () {
    function f(n) {
        return n < 10 ? "0" + n : n
    }

    if (typeof Date.prototype.toJSON !== "function") {
        Date.prototype.toJSON = function (key) {
            return isFinite(this.valueOf()) ? this.getUTCFullYear() + "-" + f(this.getUTCMonth() + 1) + "-" + f(this.getUTCDate()) + "T" + f(this.getUTCHours()) + ":" + f(this.getUTCMinutes()) + ":" + f(this.getUTCSeconds()) + "Z" : null
        };
        String.prototype.toJSON = Number.prototype.toJSON = Boolean.prototype.toJSON = function (key) {
            return this.valueOf()
        }
    }
    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = {"\b":"\\b", "\t":"\\t", "\n":"\\n", "\f":"\\f", "\r":"\\r", '"':'\\"', "\\":"\\\\"}, rep;

    function quote(string) {
        escapable.lastIndex = 0;
        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
            var c = meta[a];
            return typeof c === "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
        }) + '"' : '"' + string + '"'
    }

    function str(key, holder) {
        var i, k, v, length, mind = gap, partial, value = holder[key];
        if (value && typeof value === "object" && typeof value.toJSON === "function") {
            value = value.toJSON(key)
        }
        if (typeof rep === "function") {
            value = rep.call(holder, key, value)
        }
        switch (typeof value) {
            case"string":
                return quote(value);
            case"number":
                return isFinite(value) ? String(value) : "null";
            case"boolean":
            case"null":
                return String(value);
            case"object":
                if (!value) {
                    return"null"
                }
                gap += indent;
                partial = [];
                if (Object.prototype.toString.apply(value) === "[object Array]") {
                    length = value.length;
                    for (i = 0; i < length; i += 1) {
                        partial[i] = str(i, value) || "null"
                    }
                    v = partial.length === 0 ? "[]" : gap ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]" : "[" + partial.join(",") + "]";
                    gap = mind;
                    return v
                }
                if (rep && typeof rep === "object") {
                    length = rep.length;
                    for (i = 0; i < length; i += 1) {
                        k = rep[i];
                        if (typeof k === "string") {
                            v = str(k, value);
                            if (v) {
                                partial.push(quote(k) + (gap ? ": " : ":") + v)
                            }
                        }
                    }
                } else {
                    for (k in value) {
                        if (Object.hasOwnProperty.call(value, k)) {
                            v = str(k, value);
                            if (v) {
                                partial.push(quote(k) + (gap ? ": " : ":") + v)
                            }
                        }
                    }
                }
                v = partial.length === 0 ? "{}" : gap ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}" : "{" + partial.join(",") + "}";
                gap = mind;
                return v
        }
        return v
    }

    if (typeof JSON.stringify !== "function") {
        JSON.stringify = function (value, replacer, space) {
            var i;
            gap = "";
            indent = "";
            if (typeof space === "number") {
                for (i = 0; i < space; i += 1) {
                    indent += " "
                }
            } else {
                if (typeof space === "string") {
                    indent = space
                }
            }
            rep = replacer;
            if (replacer && typeof replacer !== "function" && (typeof replacer !== "object" || typeof replacer.length !== "number")) {
                throw new Error("JSON.stringify")
            }
            return str("", {"":value})
        }
    }
    if (typeof JSON.parse !== "function") {
        JSON.parse = function (text, reviver) {
            var j;

            function walk(holder, key) {
                var k, v, value = holder[key];
                if (value && typeof value === "object") {
                    for (k in value) {
                        if (Object.hasOwnProperty.call(value, k)) {
                            v = walk(value, k);
                            if (v !== undefined) {
                                value[k] = v
                            } else {
                                delete value[k]
                            }
                        }
                    }
                }
                return reviver.call(holder, key, value)
            }

            text = String(text);
            cx.lastIndex = 0;
            if (cx.test(text)) {
                text = text.replace(cx, function (a) {
                    return"\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
                })
            }
            if (/^[\],:{}\s]*$/.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, ""))) {
                j = eval("(" + text + ")");
                return typeof reviver === "function" ? walk({"":j}, "") : j
            }
            throw new SyntaxError("JSON.parse")
        }
    }
}());
Ext.util.JSON = {encode:function (a) {
    return JSON.stringify(a)
}, decode:function (a) {
    return JSON.parse(a)
}};
Ext.encode = Ext.util.JSON.encode;
Ext.decode = Ext.util.JSON.decode;
Ext.util.JSONP = {queue:[], current:null, request:function (d) {
    d = d || {};
    if (!d.url) {
        return
    }
    var b = this;
    d.params = d.params || {};
    if (d.callbackKey) {
        d.params[d.callbackKey] = "Ext.util.JSONP.callback"
    }
    var c = Ext.urlEncode(d.params);
    var a = document.createElement("script");
    a.type = "text/javascript";
    this.queue.push({url:d.url, script:a, callback:d.callback || function () {
    }, scope:d.scope || window, params:c || null});
    if (!this.current) {
        this.next()
    }
}, next:function () {
    this.current = null;
    if (this.queue.length) {
        this.current = this.queue.shift();
        this.current.script.src = this.current.url + (this.current.params ? ("?" + this.current.params) : "");
        document.getElementsByTagName("head")[0].appendChild(this.current.script)
    }
}, callback:function (a) {
    this.current.callback.call(this.current.scope, a);
    document.getElementsByTagName("head")[0].removeChild(this.current.script);
    this.next()
}};
Ext.util.Draggable = Ext.extend(Ext.util.Observable, {baseCls:"x-draggable", draggingCls:"x-dragging", proxyCls:"x-draggable-proxy", outOfBoundRestrictFactor:1, direction:"both", fps:Ext.is.Blackberry ? 25 : ((Ext.is.iOS || Ext.is.Desktop) ? 80 : 50), constrain:window, threshold:0, delay:0, cancelSelector:null, disabled:false, revert:false, group:"base", useCssTransform:true, grid:null, snap:null, proxy:null, stack:false, animationDuration:300, updateBoundaryOnTouchStart:true, offsetBoundary:null, dragging:false, vertical:false, horizontal:false, monitorOrientation:true, constructor:function (b, a) {
    this.el = Ext.get(b);
    this.id = b.id;
    a = a || {};
    Ext.apply(this, a);
    this.addEvents("offsetchange", "offsetboundaryupdate");
    Ext.util.Draggable.superclass.constructor.call(this, a);
    if (this.eventTarget === "parent") {
        this.eventTarget = this.el.parent()
    } else {
        this.eventTarget = (this.eventTarget) ? Ext.get(this.eventTarget) : this.el
    }
    if (this.direction == "both") {
        this.horizontal = true;
        this.vertical = true
    } else {
        if (this.direction == "horizontal") {
            this.horizontal = true
        } else {
            this.vertical = true
        }
    }
    this.el.addCls(this.baseCls);
    if (this.proxy) {
        this.getProxyEl().addCls(this.proxyCls)
    }
    this.startEventName = (this.delay > 0) ? "taphold" : "dragstart";
    this.dragOptions = (this.delay > 0) ? {holdThreshold:this.delay} : {direction:this.direction, dragThreshold:this.threshold};
    this.container = window;
    if (this.constrain) {
        if (this.constrain === "parent") {
            this.container = this.el.parent()
        } else {
            if (this.constrain !== window) {
                this.container = Ext.get(this.constrain)
            }
        }
    }
    this.offset = new Ext.util.Offset();
    this.linearAnimation = {x:new Ext.util.Draggable.Animation.Linear(), y:new Ext.util.Draggable.Animation.Linear()};
    this.updateBoundary(true);
    this.setDragging(false);
    if (!this.disabled) {
        this.enable()
    }
    return this
}, enable:function () {
    return this.setEnabled(true)
}, disable:function () {
    return this.setEnabled(false)
}, setEnabled:function (a) {
    this.eventTarget[a ? "on" : "un"](this.startEventName, this.onStart, this, this.dragOptions);
    this.eventTarget[a ? "on" : "un"]("drag", this.onDrag, this, this.dragOptions);
    this.eventTarget[a ? "on" : "un"]("dragend", this.onDragEnd, this, this.dragOptions);
    this.eventTarget[a ? "on" : "un"]("touchstart", this.onTouchStart, this);
    if (a) {
        Ext.EventManager.onOrientationChange(this.onOrientationChange, this)
    } else {
        Ext.EventManager.orientationEvent.removeListener(this.onOrientationChange, this)
    }
    this.disabled = !a;
    return this
}, setUseCssTransform:function (a) {
    if (typeof a == "undefined") {
        a = true
    }
    if (a != this.useCssTransform) {
        this.useCssTransform = a;
        var b = new Ext.util.Offset();
        if (a == false) {
            this.setStyleOffset(this.offset);
            this.setTransformOffset(b, true)
        } else {
            this.setTransformOffset(this.offset);
            this.setStyleOffset(b)
        }
    }
    return this
}, setOffset:function (b, a) {
    if (!this.horizontal) {
        b.x = 0
    }
    if (!this.vertical) {
        b.y = 0
    }
    if (!(b instanceof Ext.util.Offset)) {
        b = Ext.util.Offset.fromObject(b)
    }
    b.round();
    if (!this.offset.equals(b)) {
        if (a) {
            this.startAnimation(b, a)
        } else {
            this.offset = b;
            this.region = new Ext.util.Region(this.initialRegion.top + b.y, this.initialRegion.right + b.x, this.initialRegion.bottom + b.y, this.initialRegion.left + b.x);
            if (this.useCssTransform) {
                this.setTransformOffset(b)
            } else {
                this.setStyleOffset(b)
            }
            this.fireEvent("offsetchange", this, this.offset)
        }
    }
    return this
}, setTransformOffset:function (b, a) {
    if (a) {
        this.getProxyEl().dom.style.webkitTransform = ""
    } else {
        Ext.Element.cssTranslate(this.getProxyEl(), b)
    }
    return this
}, setStyleOffset:function (b) {
    var a = this.getProxyEl();
    a.dom.style.left = b.x + "px";
    a.dom.style.top = b.y + "px";
    return this
}, startAnimation:function (d, a) {
    var c = this;
    this.stopAnimation();
    var b = Date.now();
    a = Ext.isNumber(a) ? a : this.animationDuration;
    this.linearAnimation.x.set({startOffset:this.offset.x, endOffset:d.x, startTime:b, duration:a});
    this.linearAnimation.y.set({startOffset:this.offset.y, endOffset:d.y, startTime:b, duration:a});
    this.isAnimating = true;
    this.animationTimer = setInterval(function () {
        c.handleAnimationFrame()
    }, this.getFrameDuration());
    return this
}, getFrameDuration:function () {
    return 1000 / this.fps
}, stopAnimation:function () {
    if (this.isAnimating) {
        clearInterval(this.animationTimer);
        this.isAnimating = false;
        this.setDragging(false)
    }
    return this
}, handleAnimationFrame:function () {
    if (!this.isAnimating) {
        return
    }
    var a = new Ext.util.Offset();
    a.x = this.linearAnimation.x.getOffset();
    a.y = this.linearAnimation.y.getOffset();
    this.setOffset(a);
    if ((a.x === this.linearAnimation.x.endOffset) && (a.y === this.linearAnimation.y.endOffset)) {
        this.stopAnimation()
    }
}, getOffset:function () {
    var a = this.offset.copy();
    a.y = -a.y;
    a.x = -a.x;
    return a
}, updateBoundary:function (f) {
    var h;
    if (typeof f == "undefined") {
        f = false
    }
    this.size = {width:this.el.dom.scrollWidth, height:this.el.dom.scrollHeight};
    if (this.container === window) {
        this.containerBox = {left:0, top:0, right:this.container.innerWidth, bottom:this.container.innerHeight, width:this.container.innerWidth, height:this.container.innerHeight}
    } else {
        this.containerBox = this.container.getPageBox()
    }
    var a = this.el.getXY();
    this.elBox = {left:a[0] - this.offset.x, top:a[1] - this.offset.y, width:this.size.width, height:this.size.height};
    this.elBox.bottom = this.elBox.top + this.elBox.height;
    this.elBox.right = this.elBox.left + this.elBox.width;
    this.initialRegion = this.region = new Ext.util.Region(a[1], a[0] + this.elBox.width, a[1] + this.elBox.height, a[0]);
    var e = 0, c = 0, b = 0, d = 0;
    if (this.elBox.left < this.containerBox.left) {
        c += this.containerBox.left - this.elBox.left
    } else {
        d -= this.elBox.left - this.containerBox.left
    }
    if (this.elBox.right > this.containerBox.right) {
        d -= this.elBox.right - this.containerBox.right
    } else {
        c += this.containerBox.right - this.elBox.right
    }
    if (this.elBox.top < this.containerBox.top) {
        b += this.containerBox.top - this.elBox.top
    } else {
        e -= this.elBox.top - this.containerBox.top
    }
    if (this.elBox.bottom > this.containerBox.bottom) {
        e -= this.elBox.bottom - this.containerBox.bottom
    } else {
        b += this.containerBox.bottom - this.elBox.bottom
    }
    h = new Ext.util.Region(e, c, b, d).round();
    if (this.offsetBoundary && this.offsetBoundary.equals(h)) {
        return this
    }
    this.offsetBoundary = h;
    this.fireEvent("offsetboundaryupdate", this, this.offsetBoundary);
    var g;
    if (this.useCssTransform) {
        g = Ext.Element.getComputedTransformOffset(this.getProxyEl());
        if (!this.offset.equals(g) || f) {
            this.setOffset(g)
        }
    }
    return this
}, onTouchStart:function () {
}, onStart:function (a) {
    if (this.updateBoundaryOnTouchStart) {
        this.updateBoundary()
    }
    this.stopAnimation();
    this.setDragging(true);
    this.startTouchPoint = new Ext.util.Point(a.startX, a.startY);
    this.startOffset = this.offset.copy();
    this.fireEvent("dragstart", this, a);
    return true
}, getNewOffsetFromTouchPoint:function (a) {
    var c = a.x - this.startTouchPoint.x, b = a.y - this.startTouchPoint.y, d = this.offset.copy();
    if (c == 0 && b == 0) {
        return d
    }
    if (this.horizontal) {
        d.x = this.startOffset.x + c
    }
    if (this.vertical) {
        d.y = this.startOffset.y + b
    }
    return d
}, onDrag:function (a) {
    if (!this.dragging) {
        return
    }
    this.lastTouchPoint = Ext.util.Point.fromEvent(a);
    var b = this.getNewOffsetFromTouchPoint(this.lastTouchPoint);
    if (this.offsetBoundary != null) {
        b = this.offsetBoundary.restrict(b, this.outOfBoundRestrictFactor)
    }
    this.setOffset(b);
    this.fireEvent("drag", this, a);
    return true
}, onDragEnd:function (a) {
    if (this.dragging) {
        this.fireEvent("beforedragend", this, a);
        if (this.revert && !this.cancelRevert) {
            this.setOffset(this.startOffset, true)
        } else {
            this.setDragging(false)
        }
        this.fireEvent("dragend", this, a)
    }
    return true
}, onOrientationChange:function () {
    this.updateBoundary()
}, setDragging:function (a) {
    if (a) {
        if (!this.dragging) {
            this.dragging = true;
            this.getProxyEl().addCls(this.draggingCls)
        }
    } else {
        if (this.dragging) {
            this.dragging = false;
            this.getProxyEl().removeCls(this.draggingCls)
        }
    }
    return this
}, getProxyEl:function () {
    return this.proxy || this.el
}, destroy:function () {
    this.el.removeCls(this.baseCls);
    this.getProxyEl().removeCls(this.proxyCls);
    this.clearListeners();
    this.disable()
}, reset:function () {
    this.startOffset = new Ext.util.Offset(0, 0);
    this.setOffset(this.startOffset);
    var a = this.initialRegion.copy();
    this.updateBoundary();
    this.initialRegion = this.region = this.getProxyEl().getPageBox(true);
    this.startTouchPoint.x += this.initialRegion.left - a.left;
    this.startTouchPoint.y += this.initialRegion.top - a.top
}, moveTo:function (a, b) {
    this.setOffset(new Ext.util.Offset(a - this.initialRegion.left, b - this.initialRegion.top));
    return this
}, isDragging:function () {
    return this.dragging
}, isVertical:function () {
    return this.vertical
}, isHorizontal:function () {
    return this.horizontal
}});
Ext.util.Draggable.Animation = {};
Ext.util.Draggable.Animation.Abstract = Ext.extend(Object, {startTime:null, startOffset:0, constructor:function (a) {
    a = a || {};
    this.set(a);
    if (!this.startTime) {
        this.startTime = Date.now()
    }
}, set:function (a, b) {
    if (Ext.isObject(a)) {
        Ext.apply(this, a)
    } else {
        this[a] = b
    }
    return this
}, getOffset:Ext.emptyFn});
Ext.util.Draggable.Animation.Linear = Ext.extend(Ext.util.Draggable.Animation.Abstract, {duration:0, endOffset:0, getOffset:function () {
    var c = this.endOffset - this.startOffset, a = Date.now() - this.startTime, b = Math.min(1, (a / this.duration));
    return this.startOffset + (b * c)
}});
Ext.util.Droppable = Ext.extend(Ext.util.Observable, {baseCls:"x-droppable", activeCls:"x-drop-active", invalidCls:"x-drop-invalid", hoverCls:"x-drop-hover", validDropMode:"intersect", disabled:false, group:"base", tolerance:null, monitoring:false, constructor:function (b, a) {
    a = a || {};
    Ext.apply(this, a);
    this.addEvents("dropactivate", "dropdeactivate", "dropenter", "dropleave", "drop");
    this.el = Ext.get(b);
    Ext.util.Droppable.superclass.constructor.call(this);
    if (!this.disabled) {
        this.enable()
    }
    this.el.addCls(this.baseCls)
}, onDragStart:function (a, b) {
    if (a.group === this.group) {
        this.monitoring = true;
        this.el.addCls(this.activeCls);
        this.region = this.el.getPageBox(true);
        a.on({drag:this.onDrag, beforedragend:this.onBeforeDragEnd, dragend:this.onDragEnd, scope:this});
        if (this.isDragOver(a)) {
            this.setCanDrop(true, a, b)
        }
        this.fireEvent("dropactivate", this, a, b)
    } else {
        a.on({dragend:function () {
            this.el.removeCls(this.invalidCls)
        }, scope:this, single:true});
        this.el.addCls(this.invalidCls)
    }
}, isDragOver:function (a, b) {
    return this.region[this.validDropMode](a.region)
}, onDrag:function (a, b) {
    this.setCanDrop(this.isDragOver(a), a, b)
}, setCanDrop:function (c, a, b) {
    if (c && !this.canDrop) {
        this.canDrop = true;
        this.el.addCls(this.hoverCls);
        this.fireEvent("dropenter", this, a, b)
    } else {
        if (!c && this.canDrop) {
            this.canDrop = false;
            this.el.removeCls(this.hoverCls);
            this.fireEvent("dropleave", this, a, b)
        }
    }
}, onBeforeDragEnd:function (a, b) {
    a.cancelRevert = this.canDrop
}, onDragEnd:function (a, b) {
    this.monitoring = false;
    this.el.removeCls(this.activeCls);
    a.un({drag:this.onDrag, beforedragend:this.onBeforeDragEnd, dragend:this.onDragEnd, scope:this});
    if (this.canDrop) {
        this.canDrop = false;
        this.el.removeCls(this.hoverCls);
        this.fireEvent("drop", this, a, b)
    }
    this.fireEvent("dropdeactivate", this, a, b)
}, enable:function () {
    if (!this.mgr) {
        this.mgr = Ext.util.Observable.observe(Ext.util.Draggable)
    }
    this.mgr.on({dragstart:this.onDragStart, scope:this});
    this.disabled = false
}, disable:function () {
    this.mgr.un({dragstart:this.onDragStart, scope:this});
    this.disabled = true
}, isDisabled:function () {
    return this.disabled
}, isMonitoring:function () {
    return this.monitoring
}});
(function () {
    Ext.ScrollManager = new Ext.AbstractManager();
    Ext.util.ScrollView = Ext.extend(Ext.util.Observable, {useIndicators:true, indicatorConfig:{}, indicatorMargin:4, constructor:function (b, a) {
        var c = [], d = ["vertical", "horizontal"];
        Ext.util.ScrollView.superclass.constructor.call(this);
        ["useIndicators", "indicatorConfig", "indicatorMargin"].forEach(function (e) {
            if (a.hasOwnProperty(e)) {
                this[e] = a[e];
                delete a[e]
            }
        }, this);
        a.scrollView = this;
        this.scroller = new Ext.util.Scroller(b, a);
        if (this.useIndicators === true) {
            d.forEach(function (e) {
                if (this.scroller[e]) {
                    c.push(e)
                }
            }, this)
        } else {
            if (d.indexOf(this.useIndicators) !== -1) {
                c.push(this.useIndicators)
            }
        }
        this.indicators = {};
        this.indicatorOffsetExtras = {};
        c.forEach(function (e) {
            this.indicators[e] = new Ext.util.Scroller.Indicator(this.scroller.container, Ext.apply({}, this.indicatorConfig, {type:e}))
        }, this);
        this.mon(this.scroller, {scrollstart:this.onScrollStart, scrollend:this.onScrollEnd, scroll:this.onScroll, scope:this})
    }, onScrollStart:function () {
        this.showIndicators()
    }, onScrollEnd:function () {
        this.hideIndicators()
    }, onScroll:function (a) {
        if (a.offsetBoundary == null || (!this.indicators.vertical && !this.indicators.horizontal)) {
            return
        }
        var c, b, e, f = a.offsetBoundary, d = a.offset;
        this.containerSize = a.containerBox;
        this.scrollerSize = a.size;
        this.outOfBoundOffset = f.getOutOfBoundOffset(d);
        this.restrictedOffset = f.restrict(d);
        this.boundarySize = f.getSize();
        if (!this.indicatorSizes) {
            this.indicatorSizes = {vertical:0, horizontal:0}
        }
        if (!this.indicatorOffsets) {
            this.indicatorOffsets = {vertical:0, horizontal:0}
        }
        Ext.iterate(this.indicators, function (h, g) {
            c = (h == "vertical") ? "height" : "width";
            b = (h == "vertical") ? "y" : "x";
            e = (h == "vertical") ? "bottom" : "right";
            if (this.scrollerSize[c] < this.containerSize[c]) {
                this.indicatorSizes[h] = this.containerSize[c] * (this.scrollerSize[c] / this.containerSize[c])
            } else {
                this.indicatorSizes[h] = this.containerSize[c] * (this.containerSize[c] / this.scrollerSize[c])
            }
            this.indicatorSizes[h] -= Math.abs(this.outOfBoundOffset[b]);
            this.indicatorSizes[h] = Math.max(this.indicatorMargin * 4, this.indicatorSizes[h]);
            if (this.boundarySize[c] != 0) {
                this.indicatorOffsets[h] = (((f[e] - this.restrictedOffset[b]) / this.boundarySize[c]) * (this.containerSize[c] - this.indicatorSizes[h]))
            } else {
                if (d[b] < f[e]) {
                    this.indicatorOffsets[h] = this.containerSize[c] - this.indicatorSizes[h]
                } else {
                    this.indicatorOffsets[h] = 0
                }
            }
            g.setOffset(this.indicatorOffsetExtras[h] + this.indicatorOffsets[h] + this.indicatorMargin);
            g.setSize(this.indicatorSizes[h] - (this.indicatorMargin * 2))
        }, this)
    }, showIndicators:function () {
        Ext.iterate(this.indicators, function (b, a) {
            a.show();
            this.indicatorOffsetExtras[b] = a.el.dom.parentNode[b === "vertical" ? "scrollTop" : "scrollLeft"]
        }, this);
        return this
    }, hideIndicators:function () {
        Ext.iterate(this.indicators, function (b, a) {
            a.hide()
        }, this)
    }, destroy:function () {
        this.scroller.destroy();
        if (this.indicators) {
            Ext.iterate(this.indicators, function (b, a) {
                a.destroy()
            }, this)
        }
        return Ext.util.ScrollView.superclass.destroy.apply(this, arguments)
    }});
    Ext.util.Scroller = Ext.extend(Ext.util.Draggable, {baseCls:"", draggingCls:"", direction:"both", constrain:"parent", outOfBoundRestrictFactor:0.5, acceleration:20, autoAdjustFps:false, friction:0.5, startMomentumResetTime:350, springTension:0.3, minVelocityForAnimation:1, bounces:true, momentum:true, cancelRevert:true, threshold:5, constructor:function (f, d) {
        f = Ext.get(f);
        var a = Ext.ScrollManager.get(f.id);
        if (a) {
            return Ext.apply(a, d)
        }
        Ext.util.Scroller.superclass.constructor.apply(this, arguments);
        this.addEvents("scrollstart", "scroll", "scrollend", "bouncestart", "bounceend");
        this.on({dragstart:this.onDragStart, offsetchange:this.onOffsetChange, scope:this});
        Ext.ScrollManager.register(this);
        this.el.addCls("x-scroller");
        this.container.addCls("x-scroller-parent");
        if (this.bounces !== false) {
            var e = this.bounces === "both" || this.bounces === true, b = e || this.bounces === "horizontal", c = e || this.bounces === "vertical";
            this.bounces = {x:b, y:c}
        }
        this.theta = Math.log(1 - (this.friction / 10));
        this.bouncingVelocityFactor = this.springTension * Math.E;
        this.bouncingTimeFactor = ((1 / this.springTension) * this.acceleration);
        if (!this.decelerationAnimation) {
            this.decelerationAnimation = {}
        }
        if (!this.bouncingAnimation) {
            this.bouncingAnimation = {}
        }
        ["x", "y"].forEach(function (g) {
            if (!this.decelerationAnimation[g]) {
                this.decelerationAnimation[g] = new Ext.util.Scroller.Animation.Deceleration({acceleration:this.acceleration, theta:this.theta})
            }
            if (!this.bouncingAnimation[g]) {
                this.bouncingAnimation[g] = new Ext.util.Scroller.Animation.Bouncing({acceleration:this.acceleration, springTension:this.springTension})
            }
        }, this);
        return this
    }, updateBoundary:function (a) {
        Ext.util.Scroller.superclass.updateBoundary.apply(this, arguments);
        this.snapToBoundary(a);
        return this
    }, onOffsetChange:function (a, b) {
        this.fireEvent("scroll", a, {x:-b.x, y:-b.y})
    }, onTouchStart:function (a) {
        Ext.util.Scroller.superclass.onTouchStart.apply(this, arguments);
        this.stopMomentumAnimation()
    }, onDragStart:function (a) {
        this.fireEvent("scrollstart", this, a)
    }, setStartTime:function (a) {
        this.startTime = a.time;
        this.originalStartTime = (a.event.originalTimeStamp) ? a.event.originalTimeStamp : a.time
    }, onStart:function (a) {
        if (Ext.util.Scroller.superclass.onStart.apply(this, arguments) !== true) {
            return
        }
        this.setStartTime(a);
        this.lastEventTime = a.time;
        this.startTimeOffset = this.offset.copy();
        this.isScrolling = true;
        this.momentumAnimationFramesHandled = 0
    }, onDrag:function (a) {
        if (Ext.util.Scroller.superclass.onDrag.apply(this, arguments) !== true) {
            return
        }
        this.lastEventTime = a.time;
        if (this.lastEventTime - this.startTime > this.startMomentumResetTime) {
            this.setStartTime(a);
            this.startTimeOffset = this.offset.copy()
        }
    }, onDragEnd:function (a) {
        if (Ext.util.Scroller.superclass.onDragEnd.apply(this, arguments) !== true) {
            return
        }
        if (!this.startMomentumAnimation(a)) {
            this.fireScrollEndEvent()
        }
    }, onOrientationChange:function () {
        Ext.util.Scroller.superclass.onOrientationChange.apply(this, arguments);
        this.snapToBoundary()
    }, fireScrollEndEvent:function () {
        this.isScrolling = false;
        this.isMomentumAnimating = false;
        this.snapToBoundary();
        this.fireEvent("scrollend", this, this.getOffset());
        this.snapToSlot()
    }, getLastActualFps:function () {
        var a = (this.momentumAnimationEndTime - this.momentumAnimationStartTime - this.momentumAnimationProcessingTime) / 1000;
        return this.momentumAnimationFramesHandled / a
    }, scrollTo:function (c, a) {
        this.stopMomentumAnimation();
        var b = this.offsetBoundary.restrict(new Ext.util.Offset(-c.x, -c.y));
        this.setOffset(b, a);
        return this
    }, scrollBy:function (b, a) {
        this.stopMomentumAnimation();
        var c = this.offset.copy();
        c.x += b.x;
        c.y += b.y;
        this.setOffset(c, a);
        return this
    }, setSnap:function (a) {
        this.snap = a
    }, snapToBoundary:function (a) {
        var b = this.offsetBoundary.restrict(this.offset);
        this.setOffset(b, a);
        return this
    }, snapToSlot:function () {
        var a = this.offsetBoundary.restrict(this.offset);
        a.round();
        if (this.snap) {
            if (this.snap === true) {
                this.snap = {x:50, y:50}
            } else {
                if (Ext.isNumber(this.snap)) {
                    this.snap = {x:this.snap, y:this.snap}
                }
            }
            if (this.snap.y) {
                a.y = Math.round(a.y / this.snap.y) * this.snap.y
            }
            if (this.snap.x) {
                a.x = Math.round(a.x / this.snap.x) * this.snap.x
            }
            if (!this.offset.equals(a)) {
                this.scrollTo({x:-a.x, y:-a.y}, this.snapDuration)
            }
        }
    }, startMomentumAnimation:function (g) {
        var i = this, j = (g.event.originalTimeStamp) ? g.event.originalTimeStamp : g.time, c = Math.max(40, j - this.originalStartTime);
        this.fireEvent("beforemomentumanimationstart");
        if ((!this.momentum || !(c <= this.startMomentumResetTime)) && !this.offsetBoundary.isOutOfBound(this.offset)) {
            return false
        }
        var d = this.minVelocityForAnimation, f, h = this.offset.copy(), a, b = (c / this.acceleration);
        this.isBouncing = {x:false, y:false};
        this.isDecelerating = {x:false, y:false};
        this.momentumAnimationStartTime = g.time;
        this.momentumAnimationProcessingTime = 0;
        this.bouncingData = {x:null, y:null};
        this.momentumAnimationStartVelocity = {x:(this.offset.x - this.startTimeOffset.x) / b, y:(this.offset.y - this.startTimeOffset.y) / b};
        this.momentumAnimationStartOffset = h;
        ["x", "y"].forEach(function (e) {
            this.isDecelerating[e] = (Math.abs(this.momentumAnimationStartVelocity[e]) > d);
            if (this.bounces && this.bounces[e]) {
                a = this.offsetBoundary.restrict(e, h[e]);
                if (a !== h[e]) {
                    f = (h[e] - a) * this.bouncingVelocityFactor;
                    this.bouncingData[e] = {axis:e, offset:a, time:this.momentumAnimationStartTime, velocity:f};
                    this.isBouncing[e] = true;
                    this.isDecelerating[e] = false;
                    this.fireEvent("bouncestart", this, this.bouncingData[e]);
                    this.bouncingAnimation[e].set({startTime:this.bouncingData[e].time - this.bouncingTimeFactor, startOffset:this.bouncingData[e].offset, startVelocity:this.bouncingData[e].velocity})
                }
            }
            if (this.isDecelerating[e]) {
                this.decelerationAnimation[e].set({startVelocity:this.momentumAnimationStartVelocity[e], startOffset:this.momentumAnimationStartOffset[e], startTime:this.momentumAnimationStartTime})
            }
        }, this);
        if (this.isDecelerating.x || this.isDecelerating.y || this.isBouncing.x || this.isBouncing.y) {
            this.isMomentumAnimating = true;
            this.momentumAnimationFramesHandled = 0;
            this.fireEvent("momentumanimationstart");
            i.handleMomentumAnimationFrame();
            this.momentumAnimationTimer = setInterval(function () {
                i.handleMomentumAnimationFrame()
            }, this.getFrameDuration());
            return true
        }
        return false
    }, stopMomentumAnimation:function () {
        if (this.isMomentumAnimating) {
            if (this.momentumAnimationTimer) {
                clearInterval(this.momentumAnimationTimer)
            }
            this.momentumAnimationEndTime = Date.now();
            var a = this.getLastActualFps();
            if (!this.maxFps || a > this.maxFps) {
                this.maxFps = a
            }
            if (this.autoAdjustFps) {
                this.fps = this.maxFps
            }
            this.isDecelerating = {};
            this.isBouncing = {};
            this.fireEvent("momentumanimationend");
            this.fireScrollEndEvent()
        }
        return this
    }, handleMomentumAnimationFrame:function () {
        if (!this.isMomentumAnimating) {
            return
        }
        var c = Date.now(), f = this.offset.copy(), e = this.offsetBoundary, b, a, d;
        ["x", "y"].forEach(function (g) {
            if (this.isDecelerating[g]) {
                f[g] = this.decelerationAnimation[g].getOffset();
                b = this.momentumAnimationStartVelocity[g] * this.decelerationAnimation[g].getFrictionFactor();
                d = e.getOutOfBoundOffset(g, f[g]);
                if (d !== 0) {
                    a = e.restrict(g, f[g]);
                    if (this.bounces && this.bounces[g]) {
                        this.bouncingData[g] = {axis:g, offset:a, time:c, velocity:b};
                        this.fireEvent("bouncestart", this, this.bouncingData[g]);
                        this.bouncingAnimation[g].set({startTime:this.bouncingData[g].time, startOffset:this.bouncingData[g].offset, startVelocity:this.bouncingData[g].velocity});
                        this.isBouncing[g] = true
                    }
                    this.isDecelerating[g] = false
                } else {
                    if (Math.abs(b) <= 1) {
                        this.isDecelerating[g] = false
                    }
                }
            } else {
                if (this.isBouncing[g]) {
                    f[g] = this.bouncingAnimation[g].getOffset();
                    a = e.restrict(g, f[g]);
                    if (Math.abs(f[g] - a) <= 1) {
                        this.isBouncing[g] = false;
                        this.fireEvent("bounceend", this, {axis:g});
                        f[g] = a
                    }
                }
            }
        }, this);
        if (!this.isDecelerating.x && !this.isDecelerating.y && !this.isBouncing.x && !this.isBouncing.y) {
            this.stopMomentumAnimation();
            return
        }
        this.momentumAnimationFramesHandled++;
        this.momentumAnimationProcessingTime += Date.now() - c;
        this.setOffset(f)
    }, destroy:function () {
        Ext.ScrollManager.unregister(this);
        return Ext.util.Scroller.superclass.destroy.apply(this, arguments)
    }});
    Ext.util.Scroller.Animation = {};
    Ext.util.Scroller.Animation.Deceleration = Ext.extend(Ext.util.Draggable.Animation.Abstract, {acceleration:30, theta:null, startVelocity:null, getOffset:function () {
        return this.startOffset - this.startVelocity * (1 - this.getFrictionFactor()) / this.theta
    }, getFrictionFactor:function () {
        var a = Date.now() - this.startTime;
        return Math.exp(a / this.acceleration * this.theta)
    }});
    Ext.util.Scroller.Animation.Bouncing = Ext.extend(Ext.util.Draggable.Animation.Abstract, {springTension:0.3, acceleration:30, startVelocity:null, getOffset:function () {
        var b = (Date.now() - this.startTime), a = (b / this.acceleration) * Math.pow(Math.E, -this.springTension * (b / this.acceleration));
        return this.startOffset + (this.startVelocity * a)
    }});
    Ext.util.Scroller.Indicator = Ext.extend(Object, {baseCls:"x-scrollbar", ui:"dark", type:"horizontal", constructor:function (a, b) {
        this.container = a;
        Ext.apply(this, b);
        this.el = this.container.createChild({cls:[this.baseCls, this.baseCls + "-" + this.type, this.baseCls + "-" + this.ui].join(" ")});
        this.offset = new Ext.util.Offset();
        this.hide()
    }, hide:function () {
        var a = this;
        if (this.hideTimer) {
            clearTimeout(this.hideTimer)
        }
        this.hideTimer = setTimeout(function () {
            a.el.setStyle("opacity", 0)
        }, 100);
        return this
    }, show:function () {
        if (this.hideTimer) {
            clearTimeout(this.hideTimer)
        }
        this.el.setStyle("opacity", 1);
        return this
    }, setVisibility:function (a) {
        return this[a ? "show" : "hide"]()
    }, setSize:function (a) {
        if (this.size && a > this.size) {
            a = Math.round(a)
        }
        this.el.dom.style[(this.type == "horizontal") ? "width" : "height"] = a + "px";
        this.size = a;
        return this
    }, setOffset:function (a) {
        if (this.type == "vertical") {
            this.offset.y = a
        } else {
            this.offset.x = a
        }
        if (!Ext.is.iOS && !Ext.is.Desktop) {
            if (this.type == "vertical") {
                this.el.dom.style.top = this.offset.y + "px"
            } else {
                this.el.dom.style.left = this.offset.x + "px"
            }
        } else {
            Ext.Element.cssTranslate(this.el, this.offset)
        }
        return this
    }})
})();
Ext.util.Sortable = Ext.extend(Ext.util.Observable, {baseCls:"x-sortable", direction:"vertical", cancelSelector:null, constrain:window, group:"base", revert:true, itemSelector:null, handleSelector:null, disabled:false, delay:0, sorting:false, vertical:false, vertical:false, constructor:function (b, a) {
    a = a || {};
    Ext.apply(this, a);
    this.addEvents("sortstart", "sortend", "sortchange");
    this.el = Ext.get(b);
    Ext.util.Sortable.superclass.constructor.call(this);
    if (this.direction == "horizontal") {
        this.horizontal = true
    } else {
        if (this.direction == "vertical") {
            this.vertical = true
        } else {
            this.horizontal = this.vertical = true
        }
    }
    this.el.addCls(this.baseCls);
    this.startEventName = (this.delay > 0) ? "taphold" : "tapstart";
    if (!this.disabled) {
        this.enable()
    }
}, onStart:function (b, a) {
    if (this.cancelSelector && b.getTarget(this.cancelSelector)) {
        return
    }
    if (this.handleSelector && !b.getTarget(this.handleSelector)) {
        return
    }
    if (!this.sorting) {
        this.onSortStart(b, a)
    }
}, onSortStart:function (c, b) {
    this.sorting = true;
    var a = new Ext.util.Draggable(b, {threshold:0, revert:this.revert, direction:this.direction, constrain:this.constrain === true ? this.el : this.constrain, animationDuration:100});
    a.on({drag:this.onDrag, dragend:this.onDragEnd, scope:this});
    this.dragEl = b;
    this.calculateBoxes();
    if (!a.dragging) {
        a.onStart(c)
    }
    this.fireEvent("sortstart", this, c)
}, calculateBoxes:function () {
    this.items = [];
    var b = this.el.select(this.itemSelector, false), f = b.length, a, e, c, d;
    for (a = 0; a < f; a++) {
        c = b[a];
        if (c != this.dragEl) {
            e = Ext.fly(c).getPageBox(true);
            e.el = c;
            this.items.push(e)
        }
    }
}, onDrag:function (l, c) {
    var g = this.items, f = g.length, h = l.region, d = false, b, a, j, k;
    for (b = 0; b < f; b++) {
        k = g[b];
        a = h.intersect(k);
        if (a) {
            if (this.vertical && Math.abs(a.top - a.bottom) > (h.bottom - h.top) / 2) {
                if (h.bottom > k.top && k.top > h.top) {
                    l.el.insertAfter(k.el)
                } else {
                    l.el.insertBefore(k.el)
                }
                d = true
            } else {
                if (this.horizontal && Math.abs(a.left - a.right) > (h.right - h.left) / 2) {
                    if (h.right > k.left && k.left > h.left) {
                        l.el.insertAfter(k.el)
                    } else {
                        l.el.insertBefore(k.el)
                    }
                    d = true
                }
            }
            if (d) {
                l.reset();
                l.moveTo(h.left, h.top);
                this.calculateBoxes();
                this.fireEvent("sortchange", this, l.el, this.el.select(this.itemSelector, false).indexOf(l.el.dom));
                return
            }
        }
    }
}, onDragEnd:function (a, b) {
    a.destroy();
    this.sorting = false;
    this.fireEvent("sortend", this, a, b)
}, enable:function () {
    this.el.on(this.startEventName, this.onStart, this, {delegate:this.itemSelector, holdThreshold:this.delay});
    this.disabled = false
}, disable:function () {
    this.el.un(this.startEventName, this.onStart, this);
    this.disabled = true
}, isDisabled:function () {
    return this.disabled
}, isSorting:function () {
    return this.sorting
}, isVertical:function () {
    return this.vertical
}, isHorizontal:function () {
    return this.horizontal
}});
(function () {
    Date.useStrict = false;
    function b(d) {
        var c = Array.prototype.slice.call(arguments, 1);
        return d.replace(/\{(\d+)\}/g, function (e, f) {
            return c[f]
        })
    }

    Date.formatCodeToRegex = function (d, c) {
        var e = Date.parseCodes[d];
        if (e) {
            e = typeof e == "function" ? e() : e;
            Date.parseCodes[d] = e
        }
        return e ? Ext.applyIf({c:e.c ? b(e.c, c || "{0}") : e.c}, e) : {g:0, c:null, s:Ext.util.Format.escapeRegex(d)}
    };
    var a = Date.formatCodeToRegex;
    Ext.apply(Date, {parseFunctions:{"M$":function (d, c) {
        var e = new RegExp("\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/");
        var f = (d || "").match(e);
        return f ? new Date(((f[1] || "") + f[2]) * 1) : null
    }}, parseRegexes:[], formatFunctions:{"M$":function () {
        return"\\/Date(" + this.getTime() + ")\\/"
    }}, y2kYear:50, MILLI:"ms", SECOND:"s", MINUTE:"mi", HOUR:"h", DAY:"d", MONTH:"mo", YEAR:"y", defaults:{}, dayNames:["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], monthNames:["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"], monthNumbers:{Jan:0, Feb:1, Mar:2, Apr:3, May:4, Jun:5, Jul:6, Aug:7, Sep:8, Oct:9, Nov:10, Dec:11}, getShortMonthName:function (c) {
        return Date.monthNames[c].substring(0, 3)
    }, getShortDayName:function (c) {
        return Date.dayNames[c].substring(0, 3)
    }, getMonthNumber:function (c) {
        return Date.monthNumbers[c.substring(0, 1).toUpperCase() + c.substring(1, 3).toLowerCase()]
    }, formatCodes:{d:"Ext.util.Format.leftPad(this.getDate(), 2, '0')", D:"Date.getShortDayName(this.getDay())", j:"this.getDate()", l:"Date.dayNames[this.getDay()]", N:"(this.getDay() ? this.getDay() : 7)", S:"this.getSuffix()", w:"this.getDay()", z:"this.getDayOfYear()", W:"Ext.util.Format.leftPad(this.getWeekOfYear(), 2, '0')", F:"Date.monthNames[this.getMonth()]", m:"Ext.util.Format.leftPad(this.getMonth() + 1, 2, '0')", M:"Date.getShortMonthName(this.getMonth())", n:"(this.getMonth() + 1)", t:"this.getDaysInMonth()", L:"(this.isLeapYear() ? 1 : 0)", o:"(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))", Y:"this.getFullYear()", y:"('' + this.getFullYear()).substring(2, 4)", a:"(this.getHours() < 12 ? 'am' : 'pm')", A:"(this.getHours() < 12 ? 'AM' : 'PM')", g:"((this.getHours() % 12) ? this.getHours() % 12 : 12)", G:"this.getHours()", h:"Ext.util.Format.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')", H:"Ext.util.Format.leftPad(this.getHours(), 2, '0')", i:"Ext.util.Format.leftPad(this.getMinutes(), 2, '0')", s:"Ext.util.Format.leftPad(this.getSeconds(), 2, '0')", u:"Ext.util.Format.leftPad(this.getMilliseconds(), 3, '0')", O:"this.getGMTOffset()", P:"this.getGMTOffset(true)", T:"this.getTimezone()", Z:"(this.getTimezoneOffset() * -60)", c:function () {
        for (var j = "Y-m-dTH:i:sP", g = [], f = 0, d = j.length; f < d; ++f) {
            var h = j.charAt(f);
            g.push(h == "T" ? "'T'" : Date.getFormatCode(h))
        }
        return g.join(" + ")
    }, U:"Math.round(this.getTime() / 1000)"}, isValid:function (n, c, l, j, f, g, e) {
        j = j || 0;
        f = f || 0;
        g = g || 0;
        e = e || 0;
        var k = new Date(n, c - 1, l, j, f, g, e);
        return n == k.getFullYear() && c == k.getMonth() + 1 && l == k.getDate() && j == k.getHours() && f == k.getMinutes() && g == k.getSeconds() && e == k.getMilliseconds()
    }, parseDate:function (d, f, c) {
        var e = Date.parseFunctions;
        if (e[f] == null) {
            Date.createParser(f)
        }
        return e[f](d, Ext.isDefined(c) ? c : Date.useStrict)
    }, getFormatCode:function (d) {
        var c = Date.formatCodes[d];
        if (c) {
            c = typeof c == "function" ? c() : c;
            Date.formatCodes[d] = c
        }
        return c || ("'" + Ext.util.Format.escape(d) + "'")
    }, createFormat:function (g) {
        var f = [], c = false, e = "";
        for (var d = 0; d < g.length; ++d) {
            e = g.charAt(d);
            if (!c && e == "\\") {
                c = true
            } else {
                if (c) {
                    c = false;
                    f.push("'" + Ext.util.Format.escape(e) + "'")
                } else {
                    f.push(Date.getFormatCode(e))
                }
            }
        }
        Date.formatFunctions[g] = new Function("return " + f.join("+"))
    }, createParser:function () {
        var c = ["var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,", "def = Date.defaults,", "results = String(input).match(Date.parseRegexes[{0}]);", "if(results){", "{1}", "if(u != null){", "v = new Date(u * 1000);", "}else{", "dt = (new Date()).clearTime();", "y = Ext.num(y, Ext.num(def.y, dt.getFullYear()));", "m = Ext.num(m, Ext.num(def.m - 1, dt.getMonth()));", "d = Ext.num(d, Ext.num(def.d, dt.getDate()));", "h  = Ext.num(h, Ext.num(def.h, dt.getHours()));", "i  = Ext.num(i, Ext.num(def.i, dt.getMinutes()));", "s  = Ext.num(s, Ext.num(def.s, dt.getSeconds()));", "ms = Ext.num(ms, Ext.num(def.ms, dt.getMilliseconds()));", "if(z >= 0 && y >= 0){", "v = new Date(y, 0, 1, h, i, s, ms);", "v = !strict? v : (strict === true && (z <= 364 || (v.isLeapYear() && z <= 365))? v.add(Date.DAY, z) : null);", "}else if(strict === true && !Date.isValid(y, m + 1, d, h, i, s, ms)){", "v = null;", "}else{", "v = new Date(y, m, d, h, i, s, ms);", "}", "}", "}", "if(v){", "if(zz != null){", "v = v.add(Date.SECOND, -v.getTimezoneOffset() * 60 - zz);", "}else if(o){", "v = v.add(Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));", "}", "}", "return v;"].join("\n");
        return function (l) {
            var e = Date.parseRegexes.length, n = 1, f = [], k = [], j = false, d = "", h = 0, g, m;
            for (; h < l.length; ++h) {
                d = l.charAt(h);
                if (!j && d == "\\") {
                    j = true
                } else {
                    if (j) {
                        j = false;
                        k.push(Ext.util.Format.escape(d))
                    } else {
                        g = a(d, n);
                        n += g.g;
                        k.push(g.s);
                        if (g.g && g.c) {
                            if (g.last) {
                                m = g
                            } else {
                                f.push(g.c)
                            }
                        }
                    }
                }
            }
            if (m) {
                f.push(m)
            }
            Date.parseRegexes[e] = new RegExp("^" + k.join("") + "$");
            Date.parseFunctions[l] = new Function("input", "strict", b(c, e, f.join("")))
        }
    }(), parseCodes:{d:{g:1, c:"d = parseInt(results[{0}], 10);\n", s:"(\\d{2})"}, j:{g:1, c:"d = parseInt(results[{0}], 10);\n", s:"(\\d{1,2})"}, D:function () {
        for (var c = [], d = 0; d < 7; c.push(Date.getShortDayName(d)), ++d) {
        }
        return{g:0, c:null, s:"(?:" + c.join("|") + ")"}
    }, l:function () {
        return{g:0, c:null, s:"(?:" + Date.dayNames.join("|") + ")"}
    }, N:{g:0, c:null, s:"[1-7]"}, S:{g:0, c:null, s:"(?:st|nd|rd|th)"}, w:{g:0, c:null, s:"[0-6]"}, z:{g:1, c:"z = parseInt(results[{0}], 10);\n", s:"(\\d{1,3})"}, W:{g:0, c:null, s:"(?:\\d{2})"}, F:function () {
        return{g:1, c:"m = parseInt(Date.getMonthNumber(results[{0}]), 10);\n", s:"(" + Date.monthNames.join("|") + ")"}
    }, M:function () {
        for (var c = [], d = 0; d < 12; c.push(Date.getShortMonthName(d)), ++d) {
        }
        return Ext.applyIf({s:"(" + c.join("|") + ")"}, a("F"))
    }, m:{g:1, c:"m = parseInt(results[{0}], 10) - 1;\n", s:"(\\d{2})"}, n:{g:1, c:"m = parseInt(results[{0}], 10) - 1;\n", s:"(\\d{1,2})"}, t:{g:0, c:null, s:"(?:\\d{2})"}, L:{g:0, c:null, s:"(?:1|0)"}, o:function () {
        return a("Y")
    }, Y:{g:1, c:"y = parseInt(results[{0}], 10);\n", s:"(\\d{4})"}, y:{g:1, c:"var ty = parseInt(results[{0}], 10);\ny = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n", s:"(\\d{1,2})"}, a:function () {
        return a("A")
    }, A:{calcLast:true, g:1, c:"if (results[{0}] == 'AM') {\nif (!h || h == 12) { h = 0; }\n} else { if (!h || h < 12) { h = (h || 0) + 12; }}", s:"(AM|PM)"}, g:function () {
        return a("G")
    }, G:{g:1, c:"h = parseInt(results[{0}], 10);\n", s:"(\\d{1,2})"}, h:function () {
        return a("H")
    }, H:{g:1, c:"h = parseInt(results[{0}], 10);\n", s:"(\\d{2})"}, i:{g:1, c:"i = parseInt(results[{0}], 10);\n", s:"(\\d{2})"}, s:{g:1, c:"s = parseInt(results[{0}], 10);\n", s:"(\\d{2})"}, u:{g:1, c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n", s:"(\\d+)"}, O:{g:1, c:["o = results[{0}];", "var sn = o.substring(0,1),", "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),", "mn = o.substring(3,5) % 60;", "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.util.Format.leftPad(hr, 2, '0') + Ext.util.Format.leftPad(mn, 2, '0')) : null;\n"].join("\n"), s:"([+-]\\d{4})"}, P:{g:1, c:["o = results[{0}];", "var sn = o.substring(0,1),", "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),", "mn = o.substring(4,6) % 60;", "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.util.Format.leftPad(hr, 2, '0') + Ext.util.Format.leftPad(mn, 2, '0')) : null;\n"].join("\n"), s:"([+-]\\d{2}:\\d{2})"}, T:{g:0, c:null, s:"[A-Z]{1,4}"}, Z:{g:1, c:"zz = results[{0}] * 1;\nzz = (-43200 <= zz && zz <= 50400)? zz : null;\n", s:"([+-]?\\d{1,5})"}, c:function () {
        var e = [], c = [a("Y", 1), a("m", 2), a("d", 3), a("h", 4), a("i", 5), a("s", 6), {c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"}, {c:["if(results[8]) {", "if(results[8] == 'Z'){", "zz = 0;", "}else if (results[8].indexOf(':') > -1){", a("P", 8).c, "}else{", a("O", 8).c, "}", "}"].join("\n")}];
        for (var f = 0, d = c.length; f < d; ++f) {
            e.push(c[f].c)
        }
        return{g:1, c:e.join(""), s:[c[0].s, "(?:", "-", c[1].s, "(?:", "-", c[2].s, "(?:", "(?:T| )?", c[3].s, ":", c[4].s, "(?::", c[5].s, ")?", "(?:(?:\\.|,)(\\d+))?", "(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?", ")?", ")?", ")?"].join("")}
    }, U:{g:1, c:"u = parseInt(results[{0}], 10);\n", s:"(-?\\d+)"}}})
}());
Ext.apply(Date.prototype, {dateFormat:function (a) {
    if (Date.formatFunctions[a] == null) {
        Date.createFormat(a)
    }
    return Date.formatFunctions[a].call(this)
}, getTimezone:function () {
    return this.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "")
}, getGMTOffset:function (a) {
    return(this.getTimezoneOffset() > 0 ? "-" : "+") + Ext.util.Format.leftPad(Math.floor(Math.abs(this.getTimezoneOffset()) / 60), 2, "0") + (a ? ":" : "") + Ext.util.Format.leftPad(Math.abs(this.getTimezoneOffset() % 60), 2, "0")
}, getDayOfYear:function () {
    var b = 0, e = this.clone(), a = this.getMonth(), c;
    for (c = 0, e.setDate(1), e.setMonth(0); c < a; e.setMonth(++c)) {
        b += e.getDaysInMonth()
    }
    return b + this.getDate() - 1
}, getWeekOfYear:function () {
    var a = 86400000, b = 7 * a;
    return function () {
        var d = Date.UTC(this.getFullYear(), this.getMonth(), this.getDate() + 3) / a, c = Math.floor(d / 7), e = new Date(c * b).getUTCFullYear();
        return c - Math.floor(Date.UTC(e, 0, 7) / b) + 1
    }
}(), isLeapYear:function () {
    var a = this.getFullYear();
    return !!((a & 3) == 0 && (a % 100 || (a % 400 == 0 && a)))
}, getFirstDayOfMonth:function () {
    var a = (this.getDay() - (this.getDate() - 1)) % 7;
    return(a < 0) ? (a + 7) : a
}, getLastDayOfMonth:function () {
    return this.getLastDateOfMonth().getDay()
}, getFirstDateOfMonth:function () {
    return new Date(this.getFullYear(), this.getMonth(), 1)
}, getLastDateOfMonth:function () {
    return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth())
}, getDaysInMonth:function () {
    var a = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    return function () {
        var b = this.getMonth();
        return b == 1 && this.isLeapYear() ? 29 : a[b]
    }
}(), getSuffix:function () {
    switch (this.getDate()) {
        case 1:
        case 21:
        case 31:
            return"st";
        case 2:
        case 22:
            return"nd";
        case 3:
        case 23:
            return"rd";
        default:
            return"th"
    }
}, clone:function () {
    return new Date(this.getTime())
}, isDST:function () {
    return new Date(this.getFullYear(), 0, 1).getTimezoneOffset() != this.getTimezoneOffset()
}, clearTime:function (f) {
    if (f) {
        return this.clone().clearTime()
    }
    var b = this.getDate();
    this.setHours(0);
    this.setMinutes(0);
    this.setSeconds(0);
    this.setMilliseconds(0);
    if (this.getDate() != b) {
        for (var a = 1, e = this.add(Date.HOUR, a); e.getDate() != b; a++, e = this.add(Date.HOUR, a)) {
        }
        this.setDate(b);
        this.setHours(e.getHours())
    }
    return this
}, add:function (b, c) {
    var e = this.clone();
    if (!b || c === 0) {
        return e
    }
    switch (b.toLowerCase()) {
        case Date.MILLI:
            e.setMilliseconds(this.getMilliseconds() + c);
            break;
        case Date.SECOND:
            e.setSeconds(this.getSeconds() + c);
            break;
        case Date.MINUTE:
            e.setMinutes(this.getMinutes() + c);
            break;
        case Date.HOUR:
            e.setHours(this.getHours() + c);
            break;
        case Date.DAY:
            e.setDate(this.getDate() + c);
            break;
        case Date.MONTH:
            var a = this.getDate();
            if (a > 28) {
                a = Math.min(a, this.getFirstDateOfMonth().add("mo", c).getLastDateOfMonth().getDate())
            }
            e.setDate(a);
            e.setMonth(this.getMonth() + c);
            break;
        case Date.YEAR:
            e.setFullYear(this.getFullYear() + c);
            break
    }
    return e
}, between:function (c, a) {
    var b = this.getTime();
    return c.getTime() <= b && b <= a.getTime()
}});
Date.prototype.format = Date.prototype.dateFormat;
Ext.data.Connection = Ext.extend(Ext.util.Observable, {method:"post", url:null, disableCaching:true, disableCachingParam:"_dc", timeout:30000, useDefaultHeader:true, defaultPostHeader:"application/x-www-form-urlencoded; charset=UTF-8", useDefaultXhrHeader:true, defaultXhrHeader:"XMLHttpRequest", constructor:function (a) {
    a = a || {};
    Ext.apply(this, a);
    this.addEvents("beforerequest", "requestcomplete", "requestexception");
    this.requests = {};
    Ext.data.Connection.superclass.constructor.call(this)
}, request:function (d) {
    var m = this;
    if (m.fireEvent("beforerequest", m, d) !== false) {
        var h = d.params, c = d.url || m.url, f = d.urlParams, l = m.extraParams, i, j, g, b, q, s;
        if (Ext.isFunction(h)) {
            h = h.call(d.scope || window, d)
        }
        if (Ext.isFunction(c)) {
            c = c.call(d.scope || window, d)
        }
        j = d.rawData || d.xmlData || d.jsonData || null;
        if (d.jsonData && !Ext.isPrimitive(d.jsonData)) {
            j = Ext.encode(j)
        }
        h = Ext.urlEncode(l, Ext.isObject(h) ? Ext.urlEncode(h) : h);
        f = Ext.isObject(f) ? Ext.urlEncode(f) : f;
        b = (d.method || ((h || j) ? "POST" : "GET")).toUpperCase();
        if (b === "GET" && d.disableCaching !== false && m.disableCaching) {
            c = Ext.urlAppend(c, d.disableCachingParam || m.disableCachingParam + "=" + (new Date().getTime()))
        }
        if ((b == "GET" || j) && h) {
            c = Ext.urlAppend(c, h);
            h = null
        }
        if (f) {
            c = Ext.urlAppend(c, f)
        }
        if (d.autoAbort === true || m.autoAbort) {
            m.abort()
        }
        s = this.getXhrInstance();
        s.open(b.toUpperCase(), c, true);
        g = Ext.apply({}, d.headers || {}, m.defaultHeaders || {});
        if (!g["Content-Type"] && (j || h)) {
            var p = m.defaultPostHeader, n = d.jsonData, a = d.xmlData;
            if (j) {
                if (d.rawData) {
                    p = "text/plain"
                } else {
                    if (a && Ext.isDefined(a)) {
                        p = "text/xml"
                    } else {
                        if (n && Ext.isDefined(n)) {
                            p = "application/json"
                        }
                    }
                }
            }
            g["Content-Type"] = p
        }
        if (m.useDefaultXhrHeader && !g["X-Requested-With"]) {
            g["X-Requested-With"] = m.defaultXhrHeader
        }
        for (q in g) {
            if (g.hasOwnProperty(q)) {
                try {
                    s.setRequestHeader(q, g[q])
                } catch (k) {
                    m.fireEvent("exception", q, g[q])
                }
            }
        }
        i = {id:++Ext.data.Connection.requestId, xhr:s, headers:g, options:d, timeout:setTimeout(function () {
            i.timedout = true;
            m.abort(i)
        }, d.timeout || m.timeout)};
        m.requests[i.id] = i;
        s.onreadystatechange = Ext.createDelegate(m.onStateChange, m, [i]);
        s.send(j || h || null);
        return i
    } else {
        return d.callback ? d.callback.apply(d.scope, [d, undefined, undefined]) : null
    }
}, getXhrInstance:function () {
    return new XMLHttpRequest()
}, isLoading:function (a) {
    return a && !{0:true, 4:true}[a.xhr.readyState]
}, abort:function (a) {
    if (a && this.isLoading(a)) {
        if (!a.timedout) {
            a.aborted = true
        }
        a.xhr.abort()
    } else {
        if (!a) {
            var b;
            for (b in this.requests) {
                if (!this.requests.hasOwnProperty(b)) {
                    continue
                }
                this.abort(this.requests[b])
            }
        }
    }
}, onStateChange:function (a) {
    if (a.xhr.readyState == 4) {
        clearTimeout(a.timeout);
        delete a.timeout;
        this.onComplete(a)
    }
}, onComplete:function (d) {
    var a = d.xhr.status, c = d.options, e = true, b;
    if ((a >= 200 && a < 300) || a == 304) {
        b = this.createResponse(d);
        this.fireEvent("requestcomplete", this, b, c);
        if (c.success) {
            if (!c.scope) {
                c.success(b, c)
            } else {
                c.success.call(c.scope, b, c)
            }
        }
    } else {
        e = false;
        switch (a) {
            case 12002:
            case 12029:
            case 12030:
            case 12031:
            case 12152:
            case 13030:
                b = this.createException(d);
                break;
            default:
                b = this.createResponse(d)
        }
        this.fireEvent("requestexception", this, b, c);
        if (c.failure) {
            if (!c.scope) {
                c.failure(b, c)
            } else {
                c.failure.call(c.scope, b, c)
            }
        }
    }
    if (c.callback) {
        if (!c.scope) {
            c.callback(c, e, b)
        } else {
            c.callback.call(c.scope, c, e, b)
        }
    }
    delete this.requests[d.id]
}, createResponse:function (a) {
    var g = a.xhr, b = {}, h = g.getAllResponseHeaders().replace(/\r\n/g, "\n").split("\n"), c = h.length, i, d, f, e;
    while (c--) {
        i = h[c];
        d = i.indexOf(":");
        if (d >= 0) {
            f = i.substr(0, d).toLowerCase();
            if (i.charAt(d + 1) == " ") {
                ++d
            }
            b[f] = i.substr(d + 1)
        }
    }
    delete a.xhr;
    return{request:a, requestId:a.id, status:g.status, statusText:g.statusText, getResponseHeader:function (j) {
        return b[j.toLowerCase()]
    }, getAllResponseHeaders:function () {
        return b
    }, responseText:g.responseText, responseXML:g.responseXML}
}, createException:function (a) {
    return{request:a, requestId:a.id, status:a.aborted ? -1 : 0, statusText:a.aborted ? "transaction aborted" : "communication failure", aborted:a.aborted, timedout:a.timedout}
}});
Ext.data.Connection.requestId = 0;
Ext.Ajax = new Ext.data.Connection({autoAbort:false});
Ext.util.EventSimulator = Ext.extend(Object, {supportedEvents:{touch:["touchstart", "touchmove", "touchend", "gesturestart", "gesturechange", "gestureend"], mouse:["mousedown", "mousemove", "mouseup", "click"]}, getEventTypeByName:function (b) {
    var a = null;
    Ext.iterate(this.supportedEvents, function (d, c) {
        if (c.indexOf(b) != -1) {
            a = d
        }
    });
    return a
}, fire:function (b, c, a) {
    b = b.toLowerCase();
    if (arguments.length == 2) {
        a = c;
        c = document
    }
    switch (this.getEventTypeByName(b)) {
        case"touch":
            this.fireTouchEvent.call(this, b, c, a);
            break;
        case"mouse":
            this.fireMouseEvent.call(this, b, c, a);
            break;
        default:
            throw new Error("Event type " + b + " is currently not supported")
    }
    return this
}, createEvent:function (b, a) {
}, createEventData:function (b, a) {
    switch (this.getEventTypeByName(b.type)) {
        case"touch":
            return this.createTouchEventData(b.type, b.target, b, a);
            break;
        case"mouse":
            return this.createMouseEventData(b.type, b.target, b, a);
            break;
        default:
            throw new Error("Event type " + b.type + " is currently not supported")
    }
}, fireTouchEvent:function (c, d, b) {
    var e = this.createTouchEventData(c, d, b);
    var a = this.createTouchEvent(c, e);
    a.isSimulated = true;
    return d.dispatchEvent(a)
}, createTouchEventData:function (c, d, a, b) {
    var e = {type:c, timeStamp:Date.now(), bubbles:true, cancelable:true, detail:1, screenX:0, screenY:0, pageX:0, pageY:0, clientX:0, clientY:0, ctrlKey:false, altKey:false, shiftKey:false, metaKey:false, scale:1, rotation:0};
    if (!b) {
        e.target = d;
        e.view = document.defaultView
    }
    if (a) {
        Ext.iterate(e, function (f, g) {
            if (a.hasOwnProperty(f)) {
                e[f] = a[f]
            }
        })
    }
    ["touches", "targetTouches", "changedTouches"].forEach(function (f) {
        if (a.hasOwnProperty(f)) {
            e[f] = this.createTouchList(a[f], d, b)
        } else {
            e[f] = this.createTouchList(e, d, b)
        }
    }, this);
    return e
}, createTouchEvent:function (b, c) {
    if (typeof b != "string") {
        c = b;
        b = b.type
    }
    var a = document.createEvent("TouchEvent");
    if (a.initTouchEvent.length == 9) {
        a.initTouchEvent(c.touches, c.targetTouches, c.changedTouches, b, c.view, c.screenX, c.screenY, c.clientX, c.clientY)
    } else {
        a.initTouchEvent(b, c.bubbles, c.cancelable, c.view, c.detail, c.screenX, c.screenY, c.pageX, c.pageY, c.ctrlKey, c.altKey, c.shiftKey, c.metaKey, c.touches, c.targetTouches, c.changedTouches, c.scale, c.rotation)
    }
    return a
}, createTouch:function (c, a, b) {
    if (!document.createTouch || b) {
        return{pageX:a.pageX, pageY:a.pageY, clientX:a.pageX, clientY:a.pageY, screenX:a.pageX, screenY:a.pageY, identifier:+a.identifier || 0}
    }
    return document.createTouch(document.defaultView, c, +a.identifier || 0, +a.pageX || 0, +a.pageY || 0, +a.screenX || 0, +a.screenY || 0)
}, createTouchList:function (c, e, b) {
    var f, d = [];
    if (Ext.isObject(c) && typeof c.target != "undefined") {
        c = [c]
    }
    if (c) {
        for (var a = 0; a < c.length; a++) {
            if (!b && !c[a].target) {
                c[a].target = e
            }
            f = this.createTouch(c[a].target, c[a], b);
            d.push(f)
        }
    }
    if (!document.createTouchList || b) {
        return d
    }
    return document.createTouchList.apply(document, d)
}, fireMouseEvent:function (b, e, a) {
    var d = this.createMouseEventData(b, e, a);
    var c = this.createMouseEvent(b, d);
    c.isSimulated = true;
    c.originalTimeStamp = d.timeStamp;
    return e.dispatchEvent(c)
}, createMouseEventData:function (c, g, a, b) {
    var f = {type:c, timeStamp:Date.now(), bubbles:true, cancelable:(c != "mousemove"), detail:1, screenX:0, screenY:0, pageX:0, pageY:0, clientX:0, clientY:0, ctrlKey:false, altKey:false, shiftKey:false, metaKey:false, button:0, relatedTarget:null}, e = ["screen", "client", "page"], d = {x:0, y:0};
    if (!b) {
        f.target = g;
        f.view = window
    }
    if (a) {
        Ext.iterate(f, function (h, i) {
            if (a.hasOwnProperty(h)) {
                f[h] = a[h]
            }
        })
    }
    e.forEach(function (h) {
        if (f[h + "X"] != 0) {
            d.x = f[h + "X"]
        }
        if (f[h + "Y"] != 0) {
            d.y = f[h + "Y"]
        }
    });
    e.forEach(function (h) {
        if (f[h + "X"] == 0 && d.x != 0) {
            f[h + "X"] = d.x
        }
        if (f[h + "Y"] == 0 && d.y != 0) {
            f[h + "Y"] = d.y
        }
    });
    return f
}, createMouseEvent:function (a, b) {
    var c = document.createEvent("MouseEvents");
    c.initMouseEvent(a, b.bubbles, b.cancelable, b.view, b.detail, b.screenX, b.screenY, b.clientX, b.clientY, b.ctrlKey, b.altKey, b.shiftKey, b.metaKey, b.button, b.relatedTarget);
    return c
}});
Ext.util.EventRecorder = Ext.extend(Ext.util.Observable, {eventCollection:null, currentEventSetName:null, constructor:function () {
    this.addEvents("replaystart", "beforecalculatetarget", "beforefire", "afterfire", "aftercalculatetarget", "replayend", "interrupted");
    this.eventSets = {};
    this.interruptedIndexes = {};
    return this
}, getEventSet:function (a) {
    if (typeof a != "string") {
        if (this.currentEventSetName == null) {
            throw new Error("No EventSet is currently used")
        }
        a = this.currentEventSetName
    }
    if (typeof this.eventSets[a] == "undefined") {
        this.eventSets[a] = []
    }
    return this.eventSets[a]
}, start:function (a) {
    this.currentEventSetName = a
}, record:function (a, c) {
    if (typeof a != "string") {
        if (this.currentEventSetName == null) {
            return
        }
        c = a;
        a = this.currentEventSetName
    }
    var b = this.getEventSimulator().createEventData(c, true);
    this.getEventSet(a).push(b)
}, setEventSet:function (a, b) {
    this.eventSets[a] = b
}, erase:function (a) {
    this.getEventSet(a).length = 0
}, stopReplay:function () {
    this.interruptFlag = true
}, resumeReplay:function (b) {
    var a = this.interruptedIndexes[b] || 0;
    this.replay(b, a)
}, replay:function (c, j) {
    var l = this.getEventSimulator(), k = this.getEventSet(c), i, d = 0, e = 0, b, h, f, a = ["touchmove", "touchend", "mousemove", "mouseup"], g = this;
    if (typeof j == "undefined") {
        j = 0
    }
    e = j;
    i = k.length;
    this.interruptFlag = false;
    if (i > 0) {
        this.fireEvent("replaystart", c, j);
        setTimeout(function () {
            b = k[e];
            if (b) {
                if (a.indexOf(b.type) === -1) {
                    g.fireEvent("beforecalculatetarget", b.type, b);
                    h = Ext.util.Point.fromEvent(b);
                    f = document.elementFromPoint(h.x, h.y);
                    g.fireEvent("aftercalculatetarget", b.type, f, b)
                }
                if (f) {
                    if (g.interruptFlag === true) {
                        g.interruptFlag = false;
                        g.interruptedIndexes[c] = e;
                        g.fireEvent("interrupted", e);
                        g.fireEvent("replayend", c, true);
                        return
                    }
                    g.fireEvent("beforefire", b.type, f, b);
                    l.fire(b.type, f, b);
                    g.fireEvent("afterfire", b.type, f, b)
                }
                if (++e < i) {
                    setTimeout(arguments.callee, k[e].timeStamp - b.timeStamp)
                } else {
                    g.fireEvent("replayend", c, false)
                }
            }
        }, d)
    }
}, end:function () {
    this.currentEventSetName = null
}, getEventSimulator:function () {
    if (!this._eventSimulator) {
        this._eventSimulator = new Ext.util.EventSimulator()
    }
    return this._eventSimulator
}, setEventSimulator:function (a) {
    if (!(a instanceof Ext.util.EventSimulator)) {
        throw new Error("eventSimulator must be an instance of Ext.util.EventSimulator")
    }
    this._eventSimulator = a
}, save:function (a) {
}});
Ext.gesture.Manager = new Ext.AbstractManager({eventNames:{start:"touchstart", move:"touchmove", end:"touchend"}, defaultPreventedMouseEvents:["click"], clickMoveThreshold:5, init:function () {
    this.targets = [];
    this.followTouches = [];
    this.currentGestures = [];
    this.currentTargets = [];
    if (!Ext.supports.Touch) {
        Ext.apply(this.eventNames, {start:"mousedown", move:"mousemove", end:"mouseup"})
    }
    this.listenerWrappers = {start:Ext.createDelegate(this.onTouchStart, this), move:Ext.createDelegate(this.onTouchMove, this), end:Ext.createDelegate(this.onTouchEnd, this), mouse:Ext.createDelegate(this.onMouseEvent, this)};
    this.attachListeners()
}, freeze:function () {
    this.isFrozen = true
}, thaw:function () {
    this.isFrozen = false
}, getEventSimulator:function () {
    if (!this.eventSimulator) {
        this.eventSimulator = new Ext.util.EventSimulator()
    }
    return this.eventSimulator
}, attachListeners:function () {
    Ext.iterate(this.eventNames, function (b, a) {
        document.addEventListener(a, this.listenerWrappers[b], false)
    }, this);
    if (Ext.supports.Touch) {
        this.defaultPreventedMouseEvents.forEach(function (a) {
            document.addEventListener(a, this.listenerWrappers.mouse, true)
        }, this)
    }
}, detachListeners:function () {
    Ext.iterate(this.eventNames, function (b, a) {
        document.removeEventListener(a, this.listenerWrappers[b], false)
    }, this);
    if (Ext.supports.Touch) {
        this.defaultPreventedMouseEvents.forEach(function (a) {
            document.removeEventListener(a, this.listenerWrappers.mouse, true)
        }, this)
    }
}, onMouseEvent:function (a) {
    if (!a.isSimulated) {
        a.preventDefault();
        a.stopPropagation()
    }
}, onTouchStart:function (c) {
    var a = [], b = c.target;
    if (c.stopped === true) {
        return
    }
    if (Ext.is.Android) {
        if (!(b.tagName && ["input", "textarea", "select"].indexOf(b.tagName.toLowerCase()) !== -1)) {
            c.preventDefault()
        }
    }
    if (this.isFrozen) {
        return
    }
    if (this.startEvent) {
        this.onTouchEnd(c)
    }
    this.locks = {};
    this.currentTargets = [b];
    while (b) {
        if (this.targets.indexOf(b) !== -1) {
            a.unshift(b)
        }
        b = b.parentNode;
        this.currentTargets.push(b)
    }
    this.startEvent = c;
    this.startPoint = Ext.util.Point.fromEvent(c);
    this.lastMovePoint = null;
    this.isClick = true;
    this.handleTargets(a, c)
}, onTouchMove:function (c) {
    if (Ext.is.MultiTouch) {
        c.preventDefault()
    }
    if (!this.startEvent) {
        return
    }
    if (Ext.is.Desktop) {
        c.target = this.startEvent.target
    }
    if (this.isFrozen) {
        return
    }
    var d = this.currentGestures, b, f = c.changedTouches ? c.changedTouches[0] : c;
    this.lastMovePoint = Ext.util.Point.fromEvent(c);
    if (Ext.supports.Touch && this.isClick && !this.lastMovePoint.isWithin(this.startPoint, this.clickMoveThreshold)) {
        this.isClick = false
    }
    for (var a = 0; a < d.length; a++) {
        if (c.stopped) {
            break
        }
        b = d[a];
        if (b.listenForMove) {
            b.onTouchMove(c, f)
        }
    }
}, onTouchEnd:function (g) {
    if (Ext.is.Blackberry) {
        g.preventDefault()
    }
    if (this.isFrozen) {
        return
    }
    var h = this.currentGestures.slice(0), d = h.length, c, b, a, f = false, j = g.changedTouches ? g.changedTouches[0] : g;
    if (this.startPoint) {
        a = Ext.util.Point.fromEvent(g);
        if (!(this.lastMovePoint || this.startPoint)["equals"](a)) {
            f = true
        }
    }
    for (c = 0; c < d; c++) {
        b = h[c];
        if (!g.stopped && b.listenForEnd) {
            if (f) {
                b.onTouchMove(g, j)
            }
            b.onTouchEnd(g, j)
        }
        this.stopGesture(b)
    }
    if (Ext.supports.Touch && this.isClick) {
        this.isClick = false;
        this.getEventSimulator().fire("click", this.startEvent.target, j)
    }
    this.lastMovePoint = null;
    this.followTouches = [];
    this.startedChangedTouch = false;
    this.currentTargets = [];
    this.startEvent = null;
    this.startPoint = null
}, handleTargets:function (a, d) {
    var c = a.length, b;
    this.startedChangedTouch = false;
    this.startedTouches = Ext.supports.Touch ? d.touches : [d];
    for (b = 0; b < c; b++) {
        if (d.stopped) {
            break
        }
        this.handleTarget(a[b], d, true)
    }
    for (b = c - 1; b >= 0; b--) {
        if (d.stopped) {
            break
        }
        this.handleTarget(a[b], d, false)
    }
    if (this.startedChangedTouch) {
        this.followTouches = this.followTouches.concat((Ext.supports.Touch && d.targetTouches) ? Ext.toArray(d.targetTouches) : [d])
    }
}, handleTarget:function (g, f, a) {
    var h = Ext.Element.data(g, "x-gestures") || [], d = h.length, c, b;
    for (c = 0; c < d; c++) {
        b = h[c];
        if ((!!b.capture === !!a) && (this.followTouches.length < b.touches) && ((Ext.supports.Touch && f.targetTouches) ? (f.targetTouches.length === b.touches) : true)) {
            this.startedChangedTouch = true;
            this.startGesture(b);
            if (b.listenForStart) {
                b.onTouchStart(f, f.changedTouches ? f.changedTouches[0] : f)
            }
            if (f.stopped) {
                break
            }
        }
    }
}, startGesture:function (a) {
    a.started = true;
    this.currentGestures.push(a)
}, stopGesture:function (a) {
    a.started = false;
    this.currentGestures.remove(a)
}, addEventListener:function (g, b, f, d) {
    g = Ext.getDom(g);
    d = d || {};
    var a = this.targets, c = this.getGestureName(b), h = Ext.Element.data(g, "x-gestures"), e;
    if (!h) {
        h = [];
        Ext.Element.data(g, "x-gestures", h)
    }
    if (!c) {
        throw new Error("Trying to subscribe to unknown event " + b)
    }
    if (a.indexOf(g) === -1) {
        this.targets.push(g)
    }
    e = this.get(g.id + "-" + c);
    if (!e) {
        e = this.create(Ext.apply({}, d, {target:g, type:c}));
        h.push(e)
    }
    e.addListener(b, f);
    if (this.startedChangedTouch && this.currentTargets.contains(g) && !e.started && !d.subsequent) {
        this.startGesture(e);
        if (e.listenForStart) {
            e.onTouchStart(this.startEvent, this.startedTouches[0])
        }
    }
}, removeEventListener:function (e, a, d) {
    e = Ext.getDom(e);
    var b = this.getGestureName(a), f = Ext.Element.data(e, "x-gestures") || [], c;
    c = this.get(e.id + "-" + b);
    if (c) {
        c.removeListener(a, d);
        for (b in c.listeners) {
            return
        }
        c.destroy();
        f.remove(c);
        Ext.Element.data(e, "x-gestures", f)
    }
}, getGestureName:function (a) {
    return this.names && this.names[a]
}, registerType:function (d, a) {
    var c = a.prototype.handles, b, e;
    this.types[d] = a;
    a[this.typeName] = d;
    if (!c) {
        c = a.prototype.handles = [d]
    }
    this.names = this.names || {};
    for (b = 0, e = c.length; b < e; b++) {
        this.names[c[b]] = d
    }
}});
Ext.regGesture = function () {
    return Ext.gesture.Manager.registerType.apply(Ext.gesture.Manager, arguments)
};
Ext.TouchEventObjectImpl = Ext.extend(Object, {constructor:function (b, a) {
    if (b) {
        this.setEvent(b, a)
    }
}, setEvent:function (b, a) {
    Ext.apply(this, {event:b, time:b.timeStamp});
    this.touches = b.touches || [b];
    this.changedTouches = b.changedTouches || [b];
    this.targetTouches = b.targetTouches || [b];
    if (a) {
        this.target = a.target;
        Ext.apply(this, a)
    } else {
        this.target = b.target
    }
    return this
}, stopEvent:function () {
    this.stopPropagation();
    this.preventDefault()
}, stopPropagation:function () {
    this.event.stopped = true
}, preventDefault:function () {
    this.event.preventDefault()
}, getTarget:function (b, c, a) {
    if (b) {
        return Ext.fly(this.target).findParent(b, c, a)
    } else {
        return a ? Ext.get(this.target) : this.target
    }
}});
Ext.TouchEventObject = new Ext.TouchEventObjectImpl();
Ext.gesture.Gesture = Ext.extend(Object, {listenForStart:true, listenForEnd:true, listenForMove:true, disableLocking:false, touches:1, constructor:function (a) {
    a = a || {};
    Ext.apply(this, a);
    this.target = Ext.getDom(this.target);
    this.listeners = {};
    if (!this.target) {
        throw new Error("Trying to bind a " + this.type + " event to element that does'nt exist: " + this.target)
    }
    this.id = this.target.id + "-" + this.type;
    Ext.gesture.Gesture.superclass.constructor.call(this);
    Ext.gesture.Manager.register(this)
}, addListener:function (a, b) {
    this.listeners[a] = this.listeners[a] || [];
    this.listeners[a].push(b)
}, removeListener:function (a, c) {
    var b = this.listeners[a];
    if (b) {
        b.remove(c);
        if (b.length == 0) {
            delete this.listeners[a]
        }
        for (a in this.listeners) {
            if (this.listeners.hasOwnProperty(a)) {
                return
            }
        }
        this.listeners = {}
    }
}, fire:function (d, g, a) {
    var c = this.listeners && this.listeners[d], f = c && c.length, b;
    if (!this.disableLocking && this.isLocked(d)) {
        return false
    }
    if (f) {
        a = Ext.apply(a || {}, {time:g.timeStamp, type:d, gesture:this, target:(g.target.nodeType == 3) ? g.target.parentNode : g.target});
        for (b = 0; b < f; b++) {
            c[b](g, a)
        }
    }
    return true
}, stop:function () {
    Ext.gesture.Manager.stopGesture(this)
}, lock:function () {
    if (!this.disableLocking) {
        var a = arguments, c = a.length, b;
        for (b = 0; b < c; b++) {
            Ext.gesture.Manager.locks[a[b]] = this.id
        }
    }
}, unlock:function () {
    if (!this.disableLocking) {
        var a = arguments, c = a.length, b;
        for (b = 0; b < c; b++) {
            if (Ext.gesture.Manager.locks[a[b]] == this.id) {
                delete Ext.gesture.Manager.locks[a[b]]
            }
        }
    }
}, isLocked:function (b) {
    var a = Ext.gesture.Manager.locks[b];
    return !!(a && a !== this.id)
}, getLockingGesture:function (b) {
    var a = Ext.gesture.Manager.locks[b];
    if (a) {
        return Ext.gesture.Manager.get(a) || null
    }
    return null
}, onTouchStart:Ext.emptyFn, onTouchMove:Ext.emptyFn, onTouchEnd:Ext.emptyFn, destroy:function () {
    this.stop();
    this.listeners = null;
    Ext.gesture.Manager.unregister(this)
}});
Ext.gesture.Touch = Ext.extend(Ext.gesture.Gesture, {handles:["touchstart", "touchmove", "touchend", "touchdown"], touchDownInterval:500, onTouchStart:function (a, b) {
    this.startX = this.previousX = b.pageX;
    this.startY = this.previousY = b.pageY;
    this.startTime = this.previousTime = a.timeStamp;
    this.fire("touchstart", a);
    this.lastEvent = a;
    if (this.listeners && this.listeners.touchdown) {
        this.touchDownIntervalId = setInterval(Ext.createDelegate(this.touchDownHandler, this), this.touchDownInterval)
    }
}, onTouchMove:function (a, b) {
    this.fire("touchmove", a, this.getInfo(b));
    this.lastEvent = a
}, onTouchEnd:function (a) {
    this.fire("touchend", a, this.lastInfo);
    clearInterval(this.touchDownIntervalId)
}, touchDownHandler:function () {
    this.fire("touchdown", this.lastEvent, this.lastInfo)
}, getInfo:function (e) {
    var d = Date.now(), b = e.pageX - this.startX, a = e.pageY - this.startY, c = {startX:this.startX, startY:this.startY, previousX:this.previousX, previousY:this.previousY, pageX:e.pageX, pageY:e.pageY, deltaX:b, deltaY:a, absDeltaX:Math.abs(b), absDeltaY:Math.abs(a), previousDeltaX:e.pageX - this.previousX, previousDeltaY:e.pageY - this.previousY, time:d, startTime:this.startTime, previousTime:this.previousTime, deltaTime:d - this.startTime, previousDeltaTime:d - this.previousTime};
    this.previousTime = c.time;
    this.previousX = c.pageX;
    this.previousY = c.pageY;
    this.lastInfo = c;
    return c
}});
Ext.regGesture("touch", Ext.gesture.Touch);
Ext.gesture.Tap = Ext.extend(Ext.gesture.Gesture, {handles:["tapstart", "tapcancel", "tap", "doubletap", "taphold", "singletap"], cancelThreshold:10, doubleTapThreshold:800, singleTapThreshold:400, holdThreshold:1000, fireClickEvent:false, onTouchStart:function (b, c) {
    var a = this;
    a.startX = c.pageX;
    a.startY = c.pageY;
    a.fire("tapstart", b, a.getInfo(c));
    if (this.listeners.taphold) {
        a.timeout = setTimeout(function () {
            a.fire("taphold", b, a.getInfo(c));
            delete a.timeout
        }, a.holdThreshold)
    }
    a.lastTouch = c
}, onTouchMove:function (b, c) {
    var a = this;
    if (a.isCancel(c)) {
        a.fire("tapcancel", b, a.getInfo(c));
        if (a.timeout) {
            clearTimeout(a.timeout);
            delete a.timeout
        }
        a.stop()
    }
    a.lastTouch = c
}, onTouchEnd:function (c) {
    var a = this, b = a.getInfo(a.lastTouch);
    this.fireTapEvent(c, b);
    if (a.lastTapTime && c.timeStamp - a.lastTapTime <= a.doubleTapThreshold) {
        a.lastTapTime = null;
        c.preventDefault();
        a.fire("doubletap", c, b)
    } else {
        a.lastTapTime = c.timeStamp
    }
    if (a.listeners && a.listeners.singletap && a.singleTapThreshold && !a.preventSingleTap) {
        a.fire("singletap", c, b);
        a.preventSingleTap = true;
        setTimeout(function () {
            a.preventSingleTap = false
        }, a.singleTapThreshold)
    }
    if (a.timeout) {
        clearTimeout(a.timeout);
        delete a.timeout
    }
}, fireTapEvent:function (d, c) {
    this.fire("tap", d, c);
    if (d.event) {
        d = d.event
    }
    var b = (d.changedTouches ? d.changedTouches[0] : d).target;
    if (!b.disabled && this.fireClickEvent) {
        var a = document.createEvent("MouseEvent");
        a.initMouseEvent("click", d.bubbles, d.cancelable, document.defaultView, d.detail, d.screenX, d.screenY, d.clientX, d.clientY, d.ctrlKey, d.altKey, d.shiftKey, d.metaKey, d.metaKey, d.button, d.relatedTarget);
        a.isSimulated = true;
        b.dispatchEvent(a)
    }
}, getInfo:function (c) {
    var a = c.pageX, b = c.pageY;
    return{pageX:a, pageY:b, startX:a, startY:b}
}, isCancel:function (b) {
    var a = this;
    return(Math.abs(b.pageX - a.startX) >= a.cancelThreshold || Math.abs(b.pageY - a.startY) >= a.cancelThreshold)
}});
Ext.regGesture("tap", Ext.gesture.Tap);
Ext.gesture.Swipe = Ext.extend(Ext.gesture.Gesture, {listenForEnd:false, swipeThreshold:35, swipeTime:1000, onTouchStart:function (a, b) {
    this.startTime = a.timeStamp;
    this.startX = b.pageX;
    this.startY = b.pageY;
    this.lock("scroll", "scrollstart", "scrollend")
}, onTouchMove:function (g, h) {
    var b = h.pageY - this.startY, d = h.pageX - this.startX, a = Math.abs(b), c = Math.abs(d), f = g.timeStamp - this.startTime;
    if (a - c > 3 || f > this.swipeTime) {
        this.unlock("drag", "dragstart", "dragend");
        this.stop()
    } else {
        if (c > this.swipeThreshold && c > a) {
            this.fire("swipe", g, {direction:(d < 0) ? "left" : "right", distance:c, deltaTime:f, deltaX:d});
            this.stop()
        }
    }
}});
Ext.regGesture("swipe", Ext.gesture.Swipe);
Ext.gesture.Drag = Ext.extend(Ext.gesture.Touch, {handles:["dragstart", "drag", "dragend"], dragThreshold:5, direction:"both", horizontal:false, vertical:false, constructor:function () {
    var a = this;
    Ext.gesture.Drag.superclass.constructor.apply(a, arguments);
    if (a.direction == "both") {
        a.horizontal = true;
        a.vertical = true
    } else {
        if (a.direction == "horizontal") {
            a.horizontal = true
        } else {
            a.vertical = true
        }
    }
    return a
}, onTouchStart:function (b, c) {
    var a = this;
    a.startX = a.previousX = c.pageX;
    a.startY = a.previousY = c.pageY;
    a.startTime = a.previousTime = b.timeStamp;
    a.dragging = false
}, onTouchMove:function (c, d) {
    var a = this;
    if (a.isLocked("drag")) {
        return
    }
    var b = a.getInfo(d);
    if (!a.dragging) {
        if ((!c.touches || c.touches.length < 2) && a.isDragging(b) && a.fire("dragstart", c, b)) {
            a.dragging = true;
            a.lock("drag", "dragstart", "dragend");
            a.fire("drag", c, b)
        }
    } else {
        a.fire("drag", c, b)
    }
}, onTouchEnd:function (b) {
    var a = this;
    if (a.dragging) {
        a.fire("dragend", b, a.lastInfo)
    }
    a.dragging = false
}, isDragging:function (b) {
    var a = this;
    return((a.horizontal && b.absDeltaX >= a.dragThreshold) || (a.vertical && b.absDeltaY >= a.dragThreshold))
}, isVertical:function () {
    return this.vertical
}, isHorizontal:function () {
    return this.horizontal
}});
Ext.regGesture("drag", Ext.gesture.Drag);
Ext.gesture.Pinch = Ext.extend(Ext.gesture.Gesture, {handles:["pinchstart", "pinch", "pinchend"], touches:2, onTouchStart:function (c) {
    var a = this;
    if (this.isMultiTouch(c)) {
        a.lock("swipe", "scroll", "scrollstart", "scrollend", "touchmove", "touchend", "touchstart", "tap", "tapstart", "taphold", "tapcancel", "doubletap");
        a.pinching = true;
        var b = c.targetTouches;
        a.startFirstTouch = b[0];
        a.startSecondTouch = b[1];
        a.previousDistance = a.startDistance = a.getDistance(a.startFirstTouch, a.startSecondTouch);
        a.previousScale = 1;
        a.fire("pinchstart", c, {distance:a.startDistance, scale:a.previousScale})
    } else {
        if (a.pinching) {
            a.unlock("swipe", "scroll", "scrollstart", "scrollend", "touchmove", "touchend", "touchstart", "tap", "tapstart", "taphold", "tapcancel", "doubletap");
            a.pinching = false
        }
    }
}, isMultiTouch:function (a) {
    return a && Ext.supports.Touch && a.targetTouches && a.targetTouches.length > 1
}, onTouchMove:function (a) {
    if (!this.isMultiTouch(a)) {
        this.onTouchEnd(a);
        return
    }
    if (this.pinching) {
        this.fire("pinch", a, this.getPinchInfo(a))
    }
}, onTouchEnd:function (a) {
    if (this.pinching) {
        this.fire("pinchend", a)
    }
}, getPinchInfo:function (g) {
    var b = this, c = g.targetTouches, f = c[0], a = c[1], i = b.getDistance(f, a), h = i / b.startDistance, d = {scale:h, deltaScale:h - 1, previousScale:b.previousScale, previousDeltaScale:h - b.previousScale, distance:i, deltaDistance:i - b.startDistance, startDistance:b.startDistance, previousDistance:b.previousDistance, previousDeltaDistance:i - b.previousDistance, firstTouch:f, secondTouch:a, firstPageX:f.pageX, firstPageY:f.pageY, secondPageX:a.pageX, secondPageY:a.pageY, midPointX:(f.pageX + a.pageX) / 2, midPointY:(f.pageY + a.pageY) / 2};
    b.previousScale = h;
    b.previousDistance = i;
    return d
}, getDistance:function (b, a) {
    return Math.sqrt(Math.pow(Math.abs(b.pageX - a.pageX), 2) + Math.pow(Math.abs(b.pageY - a.pageY), 2))
}});
Ext.regGesture("pinch", Ext.gesture.Pinch);
Ext.lib.Component = Ext.extend(Ext.util.Observable, {isComponent:true, renderTpl:null, tplWriteMode:"overwrite", baseCls:"x-component", disabledCls:"x-item-disabled", hidden:false, disabled:false, draggable:false, floating:false, styleHtmlContent:false, styleHtmlCls:"x-html", allowDomMove:true, autoShow:false, autoRender:false, needsLayout:false, rendered:false, constructor:function (b) {
    b = b || {};
    this.initialConfig = b;
    Ext.apply(this, b);
    this.addEvents("beforeactivate", "activate", "beforedeactivate", "deactivate", "added", "disable", "enable", "beforeshow", "show", "beforehide", "hide", "removed", "beforerender", "render", "afterrender", "beforedestroy", "destroy", "resize", "move", "beforestaterestore", "staterestore", "beforestatesave", "statesave");
    this.getId();
    this.mons = [];
    this.additionalCls = [];
    this.renderData = this.renderData || {};
    this.renderSelectors = this.renderSelectors || {};
    this.initComponent();
    Ext.ComponentMgr.register(this);
    Ext.lib.Component.superclass.constructor.call(this);
    if (this.plugins) {
        this.plugins = [].concat(this.plugins);
        for (var c = 0, a = this.plugins.length; c < a; c++) {
            this.plugins[c] = this.initPlugin(this.plugins[c])
        }
    }
    if (this.applyTo) {
        this.applyToMarkup(this.applyTo);
        delete this.applyTo
    } else {
        if (this.renderTo) {
            this.render(this.renderTo);
            delete this.renderTo
        }
    }
    if (Ext.isDefined(this.disabledClass)) {
        throw"Component: disabledClass has been deprecated. Please use disabledCls."
    }
}, initComponent:Ext.emptyFn, applyToMarkup:Ext.emptyFn, show:Ext.emptyFn, onShow:function () {
    var a = this.needsLayout;
    if (Ext.isObject(a)) {
        this.doComponentLayout(a.width, a.height, a.isSetSize)
    }
}, initPlugin:function (a) {
    if (a.ptype && typeof a.init != "function") {
        a = Ext.PluginMgr.create(a)
    } else {
        if (typeof a == "string") {
            a = Ext.PluginMgr.create({ptype:a})
        }
    }
    a.init(this);
    return a
}, render:function (b, a) {
    if (!this.rendered && this.fireEvent("beforerender", this) !== false) {
        if (this.el) {
            this.el = Ext.get(this.el)
        }
        b = this.initContainer(b);
        this.onRender(b, a);
        this.fireEvent("render", this);
        this.initContent();
        this.afterRender(b);
        this.fireEvent("afterrender", this);
        this.initEvents();
        if (this.autoShow) {
            this.show()
        }
        if (this.hidden) {
            this.onHide(false)
        }
        if (this.disabled) {
            this.disable(true)
        }
    }
    return this
}, onRender:function (b, a) {
    var c = this.el, e, d;
    a = this.getInsertPosition(a);
    if (!c) {
        if (a) {
            c = Ext.DomHelper.insertBefore(a, this.getElConfig(), true)
        } else {
            c = Ext.DomHelper.append(b, this.getElConfig(), true)
        }
    } else {
        if (this.allowDomMove !== false) {
            b.dom.insertBefore(c.dom, a)
        }
    }
    c.addCls(this.initCls());
    c.setStyle(this.initStyles());
    e = this.initRenderTpl();
    if (e) {
        d = this.initRenderData();
        e.append(c, d)
    }
    this.el = c;
    this.applyRenderSelectors();
    this.rendered = true
}, initCls:function () {
    var a = [this.baseCls];
    if (this.componentCls) {
        a.push(this.componentCls)
    } else {
        this.componentCls = this.baseCls
    }
    if (this.cls) {
        a.push(this.cls);
        delete this.cls
    }
    if (this.ui) {
        a.push(this.componentCls + "-" + this.ui)
    }
    return a.concat(this.additionalCls)
}, afterRender:function () {
    this.getComponentLayout();
    if (this.x || this.y) {
        this.setPosition(this.x, this.y)
    }
    if (this.styleHtmlContent) {
        this.getTargetEl().addCls(this.styleHtmlCls)
    }
    if (!this.ownerCt) {
        this.setSize(this.width, this.height)
    }
}, getElConfig:function () {
    return{tag:"div", id:this.id}
}, getInsertPosition:function (a) {
    if (a !== undefined) {
        if (Ext.isNumber(a)) {
            a = this.container.dom.childNodes[a]
        } else {
            a = Ext.getDom(a)
        }
    }
    return a
}, initContainer:function (a) {
    if (!a && this.el) {
        a = this.el.dom.parentNode;
        this.allowDomMove = false
    }
    this.container = Ext.get(a);
    if (this.ctCls) {
        this.container.addCls(this.ctCls)
    }
    return this.container
}, initRenderData:function () {
    return Ext.applyIf(this.renderData, {baseCls:this.baseCls, componentCls:this.componentCls})
}, initRenderTpl:function () {
    var a = this.renderTpl;
    if (a) {
        if (this.proto.renderTpl !== a) {
            if (Ext.isArray(a) || typeof a === "string") {
                a = new Ext.XTemplate(a)
            }
        } else {
            if (Ext.isArray(this.proto.renderTpl)) {
                a = this.proto.renderTpl = new Ext.XTemplate(a)
            }
        }
    }
    return a
}, initStyles:function () {
    var d = {}, a = Ext.Element, c, e, b, f;
    if (Ext.isString(this.style)) {
        b = this.style.split(";");
        for (c = 0, e = b.length; c < e; c++) {
            if (!Ext.isEmpty(b[c])) {
                f = b[c].split(":");
                d[Ext.util.Format.trim(f[0])] = Ext.util.Format.trim(f[1])
            }
        }
    } else {
        d = Ext.apply({}, this.style)
    }
    if (this.padding != undefined) {
        d.padding = a.unitizeBox((this.padding === true) ? 5 : this.padding)
    }
    if (this.margin != undefined) {
        d.margin = a.unitizeBox((this.margin === true) ? 5 : this.margin)
    }
    if (this.border != undefined) {
        d.borderWidth = a.unitizeBox((this.border === true) ? 1 : this.border)
    }
    delete this.style;
    return d
}, initContent:function () {
    var b = this.getTargetEl();
    if (this.html) {
        b.update(Ext.DomHelper.markup(this.html));
        delete this.html
    }
    if (this.contentEl) {
        var a = Ext.get(this.contentEl);
        a.show();
        b.appendChild(a.dom)
    }
    if (this.tpl) {
        if (!this.tpl.isTemplate) {
            this.tpl = new Ext.XTemplate(this.tpl)
        }
        if (this.data) {
            this.tpl[this.tplWriteMode](b, this.data);
            delete this.data
        }
    }
}, initEvents:function () {
    var c = this.afterRenderEvents, b, a;
    if (c) {
        for (b in c) {
            if (!c.hasOwnProperty(b)) {
                continue
            }
            a = c[b];
            if (this[b] && this[b].on) {
                this.mon(this[b], a)
            }
        }
    }
}, applyRenderSelectors:function () {
    var b = this.renderSelectors || {}, c = this.el.dom, a;
    for (a in b) {
        if (!b.hasOwnProperty(a)) {
            continue
        }
        this[a] = Ext.get(Ext.DomQuery.selectNode(b[a], c))
    }
}, is:function (a) {
    return Ext.ComponentQuery.is(this, a)
}, up:function (b) {
    var a = this.ownerCt;
    if (b) {
        for (; a; a = a.ownerCt) {
            if (Ext.ComponentQuery.is(a, b)) {
                return a
            }
        }
    }
    return a
}, nextSibling:function (b) {
    var f = this.ownerCt, d, e, a, g;
    if (f) {
        d = f.items;
        a = d.indexOf(this) + 1;
        if (a) {
            if (b) {
                for (e = d.getCount(); a < e; a++) {
                    if ((g = d.getAt(a)).is(b)) {
                        return g
                    }
                }
            } else {
                if (a < d.getCount()) {
                    return d.getAt(a)
                }
            }
        }
    }
    return null
}, previousSibling:function (b) {
    var e = this.ownerCt, d, a, f;
    if (e) {
        d = e.items;
        a = d.indexOf(this);
        if (a != -1) {
            if (b) {
                for (--a; a >= 0; a--) {
                    if ((f = d.getAt(a)).is(b)) {
                        return f
                    }
                }
            } else {
                if (a) {
                    return d.getAt(--a)
                }
            }
        }
    }
    return null
}, getId:function () {
    return this.id || (this.id = "ext-comp-" + (++Ext.lib.Component.AUTO_ID))
}, getItemId:function () {
    return this.itemId || this.id
}, getEl:function () {
    return this.el
}, getTargetEl:function () {
    return this.el
}, isXType:function (b, a) {
    if (Ext.isFunction(b)) {
        b = b.xtype
    } else {
        if (Ext.isObject(b)) {
            b = b.constructor.xtype
        }
    }
    return !a ? ("/" + this.getXTypes() + "/").indexOf("/" + b + "/") != -1 : this.constructor.xtype == b
}, getXTypes:function () {
    var a = this.constructor, b = [], d = this, c;
    if (!a.xtypes) {
        while (d) {
            c = d.constructor.xtype;
            if (c != undefined) {
                b.unshift(c)
            }
            d = d.constructor.superclass
        }
        a.xtypeChain = b;
        a.xtypes = b.join("/")
    }
    return a.xtypes
}, update:function (b, c, a) {
    if (this.tpl && !Ext.isString(b)) {
        this.data = b;
        if (this.rendered) {
            this.tpl[this.tplWriteMode](this.getTargetEl(), b || {})
        }
    } else {
        this.html = Ext.isObject(b) ? Ext.DomHelper.markup(b) : b;
        if (this.rendered) {
            this.getTargetEl().update(this.html, c, a)
        }
    }
    if (this.rendered) {
        this.doComponentLayout()
    }
}, setVisible:function (a) {
    return this[a ? "show" : "hide"]()
}, isVisible:function () {
    var b = !this.hidden, a = this.ownerCt;
    this.hiddenOwnerCt = false;
    if (this.destroyed) {
        return false
    }
    if (b && this.rendered && a) {
        while (a) {
            if (a.hidden || a.collapsed) {
                this.hiddenOwnerCt = a;
                b = false;
                break
            }
            a = a.ownerCt
        }
    }
    return b
}, enable:function (a) {
    if (this.rendered) {
        this.el.removeCls(this.disabledCls);
        this.el.dom.disabled = false;
        this.onEnable()
    }
    this.disabled = false;
    if (a !== true) {
        this.fireEvent("enable", this)
    }
    return this
}, disable:function (a) {
    if (this.rendered) {
        this.el.addCls(this.disabledCls);
        this.el.dom.disabled = true;
        this.onDisable()
    }
    this.disabled = true;
    if (a !== true) {
        this.fireEvent("disable", this)
    }
    return this
}, isDisabled:function () {
    return this.disabled
}, setDisabled:function (a) {
    return this[a ? "disable" : "enable"]()
}, isHidden:function () {
    return this.hidden
}, addCls:function () {
    var b = this, a = Ext.toArray(arguments);
    if (b.rendered) {
        b.el.addCls(a)
    } else {
        b.additionalCls = b.additionalCls.concat(a)
    }
    return b
}, addClass:function () {
    throw"Component: addClass has been deprecated. Please use addCls."
}, removeCls:function () {
    var b = this, a = Ext.toArray(arguments);
    if (b.rendered) {
        b.el.removeCls(a)
    } else {
        if (b.additionalCls.length) {
            Ext.each(a, function (c) {
                b.additionalCls.remove(c)
            })
        }
    }
    return b
}, removeClass:function () {
    throw"Component: removeClass has been deprecated. Please use removeCls."
}, addListener:function (b, f, e, a) {
    if (Ext.isString(b) && (Ext.isObject(f) || a && a.element)) {
        if (a.element) {
            var d = f, c;
            f = {};
            f[b] = d;
            b = a.element;
            if (e) {
                f.scope = e
            }
            for (c in a) {
                if (!a.hasOwnProperty(c)) {
                    continue
                }
                if (this.eventOptionsRe.test(c)) {
                    f[c] = a[c]
                }
            }
        }
        if (this[b] && this[b].on) {
            this.mon(this[b], f)
        } else {
            this.afterRenderEvents = this.afterRenderEvents || {};
            this.afterRenderEvents[b] = f
        }
    }
    return Ext.lib.Component.superclass.addListener.apply(this, arguments)
}, getBubbleTarget:function () {
    return this.ownerCt
}, isFloating:function () {
    return this.floating
}, isDraggable:function () {
    return !!this.draggable
}, isDroppable:function () {
    return !!this.droppable
}, onAdded:function (a, b) {
    this.ownerCt = a;
    this.fireEvent("added", this, a, b)
}, onRemoved:function () {
    this.fireEvent("removed", this, this.ownerCt);
    delete this.ownerCt
}, onEnable:Ext.emptyFn, onDisable:Ext.emptyFn, beforeDestroy:Ext.emptyFn, onResize:Ext.emptyFn, setSize:function (b, a) {
    if (Ext.isObject(b)) {
        a = b.height;
        b = b.width
    }
    if (!this.rendered || !this.isVisible()) {
        if (this.hiddenOwnerCt) {
            var c = this.hiddenOwnerCt.layoutOnShow;
            c.remove(this);
            c.add(this)
        }
        this.needsLayout = {width:b, height:a, isSetSize:true};
        if (!this.rendered) {
            this.width = (b !== undefined) ? b : this.width;
            this.height = (a !== undefined) ? a : this.height
        }
        return this
    }
    this.doComponentLayout(b, a, true);
    return this
}, setCalculatedSize:function (b, a) {
    if (Ext.isObject(b)) {
        a = b.height;
        b = b.width
    }
    if (!this.rendered || !this.isVisible()) {
        if (this.hiddenOwnerCt) {
            var c = this.hiddenOwnerCt.layoutOnShow;
            c.remove(this);
            c.add(this)
        }
        this.needsLayout = {width:b, height:a, isSetSize:false};
        return this
    }
    this.doComponentLayout(b, a);
    return this
}, doComponentLayout:function (d, a, b) {
    var c = this.getComponentLayout();
    if (this.rendered && c) {
        d = (d !== undefined || this.collapsed === true) ? d : this.width;
        a = (a !== undefined || this.collapsed === true) ? a : this.height;
        if (b) {
            this.width = d;
            this.height = a
        }
        c.layout(d, a)
    }
    return this
}, setComponentLayout:function (b) {
    var a = this.componentLayout;
    if (a && a.isLayout && a != b) {
        a.setOwner(null)
    }
    this.componentLayout = b;
    b.setOwner(this)
}, getComponentLayout:function () {
    if (!this.componentLayout || !this.componentLayout.isLayout) {
        this.setComponentLayout(Ext.layout.LayoutManager.create(this.componentLayout, "autocomponent"))
    }
    return this.componentLayout
}, afterComponentLayout:Ext.emptyFn, setPosition:function (a, b) {
    if (Ext.isObject(a)) {
        b = a.y;
        a = a.x
    }
    if (!this.rendered) {
        return this
    }
    if (a !== undefined || b !== undefined) {
        this.el.setBox(a, b);
        this.onPosition(a, b);
        this.fireEvent("move", this, a, b)
    }
    return this
}, onPosition:Ext.emptyFn, setWidth:function (a) {
    return this.setSize(a)
}, setHeight:function (a) {
    return this.setSize(undefined, a)
}, getSize:function () {
    return this.el.getSize()
}, getWidth:function () {
    return this.el.getWidth()
}, getHeight:function () {
    return this.el.getHeight()
}, setLoading:function (a, b) {
    if (this.rendered) {
        if (a) {
            this.loadMask = this.loadMask || new Ext.LoadMask(b ? this.getTargetEl() : this.el, Ext.applyIf(Ext.isObject(a) ? a : {}));
            this.loadMask.show()
        } else {
            Ext.destroy(this.loadMask);
            this.loadMask = null
        }
    }
    return this.loadMask
}, setDocked:function (a, b) {
    this.dock = a;
    if (b && this.ownerCt && this.rendered) {
        this.ownerCt.doComponentLayout()
    }
    return this
}, onDestroy:function () {
    if (this.monitorResize && Ext.EventManager.resizeEvent) {
        Ext.EventManager.resizeEvent.removeListener(this.setSize, this)
    }
    Ext.destroy(this.componentLayout, this.loadMask)
}, destroy:function () {
    if (!this.isDestroyed) {
        if (this.fireEvent("beforedestroy", this) !== false) {
            this.destroying = true;
            this.beforeDestroy();
            if (this.ownerCt && this.ownerCt.remove) {
                this.ownerCt.remove(this, false)
            }
            if (this.rendered) {
                this.el.remove()
            }
            this.onDestroy();
            Ext.ComponentMgr.unregister(this);
            this.fireEvent("destroy", this);
            this.clearListeners();
            this.destroying = false;
            this.isDestroyed = true
        }
    }
}});
Ext.lib.Component.prototype.on = Ext.lib.Component.prototype.addListener;
Ext.lib.Component.prototype.prev = Ext.lib.Component.prototype.previousSibling;
Ext.lib.Component.prototype.next = Ext.lib.Component.prototype.nextSibling;
Ext.lib.Component.AUTO_ID = 1000;
Ext.Component = Ext.extend(Ext.lib.Component, {});
Ext.reg("component", Ext.Component);
Ext.Component = Ext.extend(Ext.lib.Component, {showAnimation:null, monitorOrientation:false, floatingCls:"x-floating", hideOnMaskTap:true, stopMaskTapEvent:true, centered:false, modal:false, fullscreen:false, layoutOnOrientationChange:null, initComponent:function () {
    this.addEvents("beforeorientationchange", "orientationchange");
    if (this.fullscreen || this.floating) {
        this.monitorOrientation = true;
        this.autoRender = true
    }
    if (this.fullscreen) {
        var a = Ext.Viewport.getSize();
        this.width = a.width;
        this.height = a.height;
        this.cls = (this.cls || "") + " x-fullscreen";
        this.renderTo = document.body
    }
}, onRender:function () {
    Ext.Component.superclass.onRender.apply(this, arguments);
    if (this.monitorOrientation) {
        this.el.addCls("x-" + Ext.Viewport.orientation)
    }
    if (this.floating) {
        this.setFloating(true)
    }
    if (this.draggable) {
        this.setDraggable(this.draggable)
    }
    if (this.scroll) {
        this.setScrollable(this.scroll)
    }
}, afterRender:function () {
    if (this.fullscreen) {
        this.layoutOrientation(Ext.Viewport.orientation, this.width, this.height)
    }
    Ext.Component.superclass.afterRender.call(this)
}, initEvents:function () {
    Ext.Component.superclass.initEvents.call(this);
    if (this.monitorOrientation) {
        Ext.EventManager.onOrientationChange(this.setOrientation, this)
    }
}, afterComponentLayout:function () {
    var c = this.scrollEl, a = this.scroller, b;
    if (c) {
        b = c.parent();
        if (a.horizontal) {
            c.setStyle("min-width", b.getWidth(true) + "px");
            c.setHeight(b.getHeight(true) || null)
        }
        if (a.vertical) {
            c.setStyle("min-height", b.getHeight(true) + "px");
            c.setWidth(b.getWidth(true) || null)
        }
        a.updateBoundary(true)
    }
    if (this.fullscreen && Ext.is.iPad) {
        Ext.repaint()
    }
}, layoutOrientation:Ext.emptyFn, update:function () {
    Ext.Component.superclass.update.apply(this, arguments);
    var a = this.scroller;
    if (a && a.updateBoundary) {
        a.updateBoundary(true)
    }
}, show:function (a) {
    var b = this.rendered;
    if ((this.hidden || !b) && this.fireEvent("beforeshow", this) !== false) {
        if (this.anchorEl) {
            this.anchorEl.hide()
        }
        if (!b && this.autoRender) {
            this.render(Ext.isBoolean(this.autoRender) ? Ext.getBody() : this.autoRender)
        }
        this.hidden = false;
        if (this.rendered) {
            this.onShow(a);
            this.fireEvent("show", this)
        }
    }
    return this
}, showBy:function (b, c, d, a) {
    if (!this.floating) {
        return this
    }
    if (b.isComponent) {
        b = b.el
    } else {
        b = Ext.get(b)
    }
    this.x = 0;
    this.y = 0;
    this.show(c);
    if (a !== false) {
        if (!this.anchorEl) {
            this.anchorEl = this.el.createChild({cls:"x-anchor"})
        }
        this.anchorEl.show()
    }
    this.alignTo(b, d, 20)
}, alignTo:function (f, e, g) {
    var b = f.getPageBox(), q = {width:window.innerWidth, height:window.innerHeight}, l = this.getSize(), a = {width:Math.min(l.width, q.width), height:Math.min(l.height, q.height)}, s, j = 2, d = ["tl-bl", "t-b", "tr-br", "l-r", "l-r", "r-l", "bl-tl", "b-t", "br-tr"], p = this.anchorEl, h = [0, g], i, c, k = false, n = [0, 0], o = b.left + (b.width / 2), m = b.top + (b.height / 2);
    if (o <= q.width * (1 / 3)) {
        j = 1;
        n[0] = 25
    } else {
        if (o >= q.width * (2 / 3)) {
            j = 3;
            n[0] = -30
        }
    }
    if (m >= q.height * (2 / 3)) {
        j += 6;
        h = [0, -g];
        n[1] = -10
    } else {
        if (e !== false && m >= q.height * (1 / 3)) {
            j += 3;
            h = (j <= 5) ? [g, 0] : [-g, 0];
            n = (j <= 5) ? [10, 0] : [-10, 0];
            k = true
        } else {
            n[1] = 10
        }
    }
    s = d[j - 1];
    i = this.el.getAlignToXY(f, s, h);
    if (k) {
        if (i[0] < 0) {
            a.width = b.left - g
        } else {
            if (i[0] + a.width > q.width) {
                a.width = q.width - b.right - g
            }
        }
    } else {
        if (i[1] < 0) {
            a.height = b.top - g
        } else {
            if (i[1] + a.height > q.height) {
                a.height = q.height - b.bottom - g
            }
        }
    }
    if (a.width != l.width) {
        this.setSize(a.width)
    } else {
        if (a.height != l.height) {
            this.setSize(undefined, a.height)
        }
    }
    i = this.el.getAlignToXY(f, s, h);
    this.setPosition(i[0], i[1]);
    if (p) {
        p.removeCls(["x-anchor-bottom", "x-anchor-left", "x-anchor-right", "x-anchor-top"]);
        if (h[1] == g) {
            c = "x-anchor-top"
        } else {
            if (h[1] == -g) {
                c = "x-anchor-bottom"
            } else {
                if (h[0] == g) {
                    c = "x-anchor-left"
                } else {
                    c = "x-anchor-right"
                }
            }
        }
        i = p.getAlignToXY(f, s, n);
        p.setXY(i);
        p.addCls(c)
    }
    return s
}, setCentered:function (b, d) {
    this.centered = b;
    if (this.rendered && d) {
        var a, c;
        if (!this.ownerCt) {
            a = (Ext.Element.getViewportWidth() / 2) - (this.getWidth() / 2);
            c = (Ext.Element.getViewportHeight() / 2) - (this.getHeight() / 2)
        } else {
            a = (this.ownerCt.getTargetEl().getWidth() / 2) - (this.getWidth() / 2);
            c = (this.ownerCt.getTargetEl().getHeight() / 2) - (this.getHeight() / 2)
        }
        this.setPosition(a, c)
    }
    return this
}, hide:function (a) {
    if (!this.hidden && this.fireEvent("beforehide", this) !== false) {
        this.hidden = true;
        if (this.rendered) {
            this.onHide(a, true)
        }
    }
    return this
}, onShow:function (a) {
    this.el.show();
    Ext.Component.superclass.onShow.call(this, a);
    if (a === undefined || a === true) {
        a = this.showAnimation
    }
    if (this.floating) {
        this.el.dom.parentNode || this.el.appendTo(document.body);
        if (a) {
            this.el.setStyle("opacity", 0.01)
        }
        if (this.centered) {
            this.setCentered(true, true)
        } else {
            this.setPosition(this.x, this.y)
        }
        if (this.modal) {
            this.el.parent().mask(null, "x-mask-gray")
        }
        if (this.hideOnMaskTap) {
            Ext.getDoc().on("touchstart", this.onFloatingTouchStart, this, {capture:true, subsequent:true})
        }
    }
    if (a) {
        Ext.Anim.run(this, a, {out:false, autoClear:true});
        this.showAnimation = a
    }
}, onFloatingTouchStart:function (a) {
    if (!this.el.contains(a.target)) {
        this.hide();
        if (this.stopMaskTapEvent || Ext.fly(a.target).hasCls("x-mask")) {
            a.stopEvent()
        }
    }
}, onHide:function (b, a) {
    if (b === undefined || b === true) {
        b = this.showAnimation
    }
    if (this.hideOnMaskTap && this.floating) {
        Ext.getDoc().un("touchstart", this.onFloatingTouchStart, this, {capture:true, subsequent:true})
    }
    if (b) {
        Ext.Anim.run(this, b, {out:true, reverse:true, autoClear:true, scope:this, fireHideEvent:a, after:this.doHide})
    } else {
        this.doHide(null, {fireHideEvent:a})
    }
}, doHide:function (c, a) {
    var b = this.el.parent();
    this.el.hide();
    if (b && this.floating && this.modal) {
        b.unmask()
    }
    if (a && a.fireHideEvent) {
        this.fireEvent("hide", this)
    }
}, setScrollable:function (a) {
    var b = this, c;
    if (!b.rendered) {
        b.scroll = a;
        return
    }
    Ext.destroy(b.scroller);
    b.scroller = null;
    if (b.originalGetTargetEl) {
        b.getTargetEl = b.originalGetTargetEl
    }
    if (a !== false) {
        c = Ext.isObject(a) ? a.direction : a;
        a = Ext.apply({}, Ext.isObject(a) ? a : {}, {direction:c});
        if (!b.scrollEl) {
            b.scrollEl = b.getTargetEl().createChild()
        }
        b.originalGetTargetEl = b.getTargetEl;
        b.getTargetEl = function () {
            return b.scrollEl
        };
        b.scroller = (new Ext.util.ScrollView(b.scrollEl, a)).scroller
    }
}, setFloating:function (b, a) {
    this.floating = !!b;
    this.hidden = true;
    if (this.rendered) {
        if (b !== false) {
            this.el.addCls(this.floatingCls);
            if (a) {
                this.show()
            }
        } else {
            this.el.removeCls(this.floatingCls);
            Ext.getDoc().un("touchstart", this.onFloatingTouchStart, this)
        }
    } else {
        if (b !== false) {
            if (this.layoutOnOrientationChange !== false) {
                this.layoutOnOrientationChange = true
            }
            this.autoRender = true
        }
    }
}, setDraggable:function (a, b) {
    this.isDraggable = a;
    if (this.rendered) {
        if (a === false) {
            if (this.dragObj) {
                this.dragObj.disable()
            }
        } else {
            if (b) {
                this.show()
            }
            if (this.dragObj) {
                this.dragObj.enable()
            } else {
                this.dragObj = new Ext.util.Draggable(this.el, Ext.apply({}, this.draggable || {}));
                this.relayEvents(this.dragObj, ["dragstart", "beforedragend", "drag", "dragend"])
            }
        }
    }
}, setOrientation:function (b, a, c) {
    if (this.fireEvent("beforeorientationchange", this, b, a, c) !== false) {
        if (this.orientation != b) {
            this.el.removeCls("x-" + this.orientation);
            this.el.addCls("x-" + b)
        }
        this.orientation = b;
        this.layoutOrientation(b, a, c);
        if (this.fullscreen) {
            this.setSize(a, c)
        } else {
            if (this.layoutOnOrientationChange) {
                this.doComponentLayout()
            }
        }
        if (this.floating && this.centered) {
            this.setCentered(true, true)
        }
        this.onOrientationChange(b, a, c);
        this.fireEvent("orientationchange", this, b, a, c)
    }
}, onOrientationChange:Ext.emptyFn, beforeDestroy:function () {
    if (this.floating && this.modal && !this.hidden) {
        this.el.parent().unmask()
    }
    Ext.destroy(this.scroller);
    Ext.Component.superclass.beforeDestroy.call(this)
}, onDestroy:function () {
    if (this.monitorOrientation && Ext.EventManager.orientationEvent) {
        Ext.EventManager.orientationEvent.removeListener(this.setOrientation, this)
    }
    Ext.Component.superclass.onDestroy.call(this)
}});
Ext.BoxComponent = Ext.Component;
Ext.reg("component", Ext.Component);
Ext.reg("box", Ext.BoxComponent);
Ext.lib.Container = Ext.extend(Ext.Component, {autoDestroy:true, defaultType:"panel", isContainer:true, baseCls:"x-container", bubbleEvents:["add", "remove"], initComponent:function () {
    this.addEvents("afterlayout", "beforeadd", "beforeremove", "add", "remove", "beforecardswitch", "cardswitch");
    this.layoutOnShow = new Ext.util.MixedCollection();
    Ext.lib.Container.superclass.initComponent.call(this);
    this.initItems()
}, initItems:function () {
    var a = this.items;
    this.items = new Ext.util.MixedCollection(false, this.getComponentId);
    if (a) {
        if (!Ext.isArray(a)) {
            a = [a]
        }
        this.add(a)
    }
}, afterRender:function () {
    this.getLayout();
    Ext.lib.Container.superclass.afterRender.apply(this, arguments)
}, setLayout:function (b) {
    var a = this.layout;
    if (a && a.isLayout && a != b) {
        a.setOwner(null)
    }
    this.layout = b;
    b.setOwner(this)
}, getLayout:function () {
    if (!this.layout || !this.layout.isLayout) {
        this.setLayout(Ext.layout.LayoutManager.create(this.layout, "autocontainer"))
    }
    return this.layout
}, doLayout:function () {
    var a = this.getLayout();
    if (this.rendered && a) {
        a.layout()
    }
    return this
}, afterLayout:function (a) {
    this.fireEvent("afterlayout", this, a)
}, prepareItems:function (a, c) {
    if (!Ext.isArray(a)) {
        a = [a]
    }
    var e, b, d;
    for (b = 0, d = a.length; b < d; b++) {
        e = a[b];
        if (c) {
            e = this.applyDefaults(e)
        }
        a[b] = this.lookupComponent(e)
    }
    return a
}, applyDefaults:function (a) {
    var b = this.defaults;
    if (b) {
        if (Ext.isFunction(b)) {
            b = b.call(this, a)
        }
        if (Ext.isString(a)) {
            a = Ext.ComponentMgr.get(a);
            Ext.apply(a, b)
        } else {
            if (!a.isComponent) {
                Ext.applyIf(a, b)
            } else {
                Ext.apply(a, b)
            }
        }
    }
    return a
}, lookupComponent:function (a) {
    if (Ext.isString(a)) {
        return Ext.ComponentMgr.get(a)
    } else {
        return this.createComponent(a)
    }
    return a
}, createComponent:function (a, b) {
    if (a.isComponent) {
        return a
    }
    return Ext.create(a, b || this.defaultType)
}, getComponentId:function (a) {
    return a.getItemId()
}, add:function () {
    var f = Array.prototype.slice.call(arguments), d = -1;
    if (typeof f[0] == "number") {
        d = f.shift()
    }
    var a = f.length > 1;
    if (a || Ext.isArray(f[0])) {
        var g = a ? f : f[0], b = [], c, e, j;
        for (c = 0, e = g.length; c < e; c++) {
            j = g[c];
            if (!j) {
                throw"Trying to add a null item as a child of Container with itemId/id: " + this.getItemId()
            }
            if (d != -1) {
                j = this.add(d + c, j)
            } else {
                j = this.add(j)
            }
            b.push(j)
        }
        return b
    }
    var h = this.prepareItems(f[0], true)[0];
    d = (d !== -1) ? d : this.items.length;
    if (this.fireEvent("beforeadd", this, h, d) !== false && this.onBeforeAdd(h) !== false) {
        this.items.insert(d, h);
        h.onAdded(this, d);
        this.onAdd(h, d);
        this.fireEvent("add", this, h, d)
    }
    return h
}, onAdd:Ext.emptyFn, onRemove:Ext.emptyFn, insert:function (b, a) {
    return this.add(b, a)
}, onBeforeAdd:function (a) {
    if (a.ownerCt) {
        a.ownerCt.remove(a, false)
    }
    if (this.hideBorders === true) {
        a.border = (a.border === true)
    }
}, remove:function (a, b) {
    var d = this.getComponent(a);
    if (!d) {
        console.warn("Attempted to remove a component that does not exist. Ext.Container: remove takes an argument of the component to remove. cmp.remove() is incorrect usage.")
    }
    if (d && this.fireEvent("beforeremove", this, d) !== false) {
        this.doRemove(d, b);
        this.fireEvent("remove", this, d)
    }
    return d
}, doRemove:function (c, b) {
    var d = this.layout, a = d && this.rendered;
    this.items.remove(c);
    c.onRemoved();
    if (a) {
        d.onRemove(c)
    }
    this.onRemove(c, b);
    if (b === true || (b !== false && this.autoDestroy)) {
        c.destroy()
    }
    if (a && !b) {
        d.afterRemove(c)
    }
}, removeAll:function (b) {
    var f, d = this.items.items.slice(), a = [], e = d.length, c;
    for (c = 0; c < e; c++) {
        f = d[c];
        this.remove(f, b);
        if (f.ownerCt !== this) {
            a.push(f)
        }
    }
    return a
}, getRefItems:function (a) {
    var b = this.items.items.slice(), e = b.length, c, d;
    if (a) {
        for (c = 0; c < e; c++) {
            d = b[c];
            if (d.getRefItems) {
                b = b.concat(d.getRefItems(true))
            }
        }
    }
    return b
}, getComponent:function (a) {
    if (Ext.isObject(a)) {
        a = a.getItemId()
    }
    return this.items.get(a)
}, query:function (a) {
    return Ext.ComponentQuery.query(a, this)
}, child:function (a) {
    return this.query("> " + a)[0] || null
}, down:function (a) {
    return this.query(a)[0] || null
}, show:function () {
    Ext.lib.Container.superclass.show.apply(this, arguments);
    var e = this.layoutOnShow, d = e.getCount(), b = 0, a, c;
    for (; b < d; b++) {
        c = e.get(b);
        a = c.needsLayout;
        if (Ext.isObject(a)) {
            c.doComponentLayout(a.width, a.height, a.isSetSize)
        }
    }
    e.clear()
}, beforeDestroy:function () {
    var a = this.items, b;
    if (a) {
        while ((b = a.first())) {
            this.doRemove(b, true)
        }
    }
    Ext.destroy(this.layout);
    Ext.lib.Container.superclass.beforeDestroy.call(this)
}});
Ext.Container = Ext.extend(Ext.lib.Container, {});
Ext.reg("container", Ext.Container);
Ext.Container = Ext.extend(Ext.lib.Container, {cardSwitchAnimation:null, initComponent:function () {
    if (this.scroll) {
        this.fields = new Ext.util.MixedCollection();
        if (!Ext.is.Blackberry) {
            this.fields.on({add:this.onFieldAdd, remove:this.onFieldRemove, scope:this})
        }
        this.on({add:this.onItemAdd, remove:this.onItemRemove, scope:this})
    }
    Ext.Container.superclass.initComponent.apply(this, arguments)
}, afterRender:function () {
    Ext.Container.superclass.afterRender.apply(this, arguments);
    if (this.scroller) {
        if ((Ext.is.Android) && this.containsFormFields) {
            this.scroller.setUseCssTransform(false)
        }
        this.scroller.on("scrollstart", this.onFieldScrollStart, this)
    }
}, onFieldScrollStart:function () {
    var a = this.focusedField;
    if (a && Ext.is.iOS) {
        a.blur()
    }
}, onItemAdd:function (b, a) {
    this.fields.addAll(Ext.ComponentQuery.query("[isField]", a))
}, onItemRemove:function (b, a) {
    this.fields.removeAll(Ext.ComponentQuery.query("[isField]", a))
}, onFieldAdd:function (a, b) {
    this.handleFieldEventListener(true, b)
}, onFieldRemove:function (a, b) {
    this.handleFieldEventListener(false, b)
}, handleFieldEventListener:function (b, a) {
    if (!this.fieldEventWrap) {
        this.fieldEventWrap = {}
    }
    if (["textfield", "passwordfield", "emailfield", "textareafield", "searchfield", "urlfield", "numberfield", "spinnerfield"].indexOf(a.xtype) !== -1) {
        if (b) {
            this.fieldEventWrap[a.id] = {beforefocus:function (c) {
                this.onFieldBeforeFocus(a, c)
            }, focus:function (c) {
                this.onFieldFocus(a, c)
            }, blur:function (c) {
                this.onFieldBlur(a, c)
            }, keyup:function (c) {
                this.onFieldKeyUp(a, c)
            }, scope:this};
            this.containsFormFields = true
        }
        a[b ? "on" : "un"](this.fieldEventWrap[a.id]);
        if (!b) {
            delete this.fieldEventWrap[a.id]
        }
    }
}, onFieldKeyUp:function (b, a) {
    if (Ext.is.iOS || Ext.is.Desktop) {
        this.resetLastWindowScroll()
    }
}, onFieldBeforeFocus:function (b, a) {
    this.focusingField = b
}, getLastWindowScroll:function () {
    if (!this.lastWindowScroll) {
        this.resetLastWindowScroll()
    }
    return{x:this.lastWindowScroll.x, y:this.lastWindowScroll.y}
}, resetLastWindowScroll:function () {
    this.lastWindowScroll = {x:window.pageXOffset, y:window.pageYOffset}
}, adjustScroller:function (b) {
    var a = this.getClosestScroller(), c = this.getLastWindowScroll();
    a.setOffset(b);
    if (Ext.is.iOS) {
        window.scrollTo(c.x, c.y)
    }
    this.resetLastWindowScroll()
}, onFieldFocus:function (h, g) {
    if (!Ext.is.iOS && !Ext.is.Desktop) {
        var b = h.fieldEl.dom;
        if (b.scrollIntoViewIfNeeded) {
            b.scrollIntoViewIfNeeded(true)
        }
    } else {
        var f = this.getClosestScroller(), i = Ext.util.Region.from(f.containerBox), l = h.fieldEl.getPageBox(true);
        if (this.focusingField == h || !Ext.is.iOS) {
            if (Ext.is.iOS && window.pageYOffset == 0) {
                window.scrollTo(0, 0)
            }
            var j = new Ext.util.Offset();
            if (l.left < i.left) {
                j.x = i.left - l.left
            }
            if (l.top < i.top) {
                j.y = i.top - l.top
            }
            if (!j.isZero()) {
                var k = this.getLastWindowScroll();
                f.scrollBy(j);
                if (Ext.is.iOS) {
                    window.scrollTo(k.x, k.y)
                }
                this.resetLastWindowScroll()
            }
        } else {
            if (this.lastFocusedField) {
                var a = l.top - this.lastFocusedField.fieldEl.getY(), c = f.offset.y - a, d = false;
                if (!i.contains(l) && (c != 0 || (c == 0 && f.offset.y != 0))) {
                    d = true
                }
                if (c > 0) {
                    c = 0
                }
                if (d) {
                    this.adjustScroller(new Ext.util.Offset(f.offset.x, c))
                }
            }
        }
        this.resetLastWindowScroll()
    }
    this.lastFocusedField = h;
    this.focusedField = h;
    this.focusingField = null
}, getClosestScroller:function () {
    if (!this.closestScroller) {
        this.closestScroller = this.scroller || this.el.getScrollParent()
    }
    return this.closestScroller
}, onFieldBlur:function (b, a) {
    if (this.focusingField == b) {
        this.focusingField = null
    }
    if (this.focusedField == b) {
        this.focusedField = null
    }
}, afterLayout:function (a) {
    if (this.floating && this.centered) {
        this.setCentered(true, true)
    }
    if (this.scroller) {
        this.scroller.updateBoundary()
    }
    Ext.Container.superclass.afterLayout.call(this, a)
}, getActiveItem:function () {
    if (this.layout && this.layout.type == "card") {
        return this.layout.activeItem
    } else {
        return null
    }
}, setActiveItem:function (a, b) {
    this.layout.setActiveItem(a, b);
    return this
}, onBeforeCardSwitch:function (a, c, b, d) {
    return this.fireEvent("beforecardswitch", this, a, c, b, d)
}, onCardSwitch:function (a, c, b, d) {
    return this.fireEvent("cardswitch", this, a, c, b, d)
}, disable:function () {
    Ext.Container.superclass.disable.call(this);
    this.el.mask(null, "x-mask-gray")
}, enable:function () {
    Ext.Container.superclass.enable.call(this);
    this.el.unmask()
}});
Ext.reg("container", Ext.Container);
Ext.lib.Panel = Ext.extend(Ext.Container, {baseCls:"x-panel", isPanel:true, componentLayout:"dock", renderTpl:['<div class="{baseCls}-body<tpl if="bodyCls"> {bodyCls}</tpl>"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>></div>'], initComponent:function () {
    this.addEvents("bodyresize");
    Ext.applyIf(this.renderSelectors, {body:"." + this.baseCls + "-body"});
    Ext.lib.Panel.superclass.initComponent.call(this)
}, initItems:function () {
    Ext.lib.Panel.superclass.initItems.call(this);
    var a = this.dockedItems;
    this.dockedItems = new Ext.util.MixedCollection(false, this.getComponentId);
    if (a) {
        this.addDocked(a)
    }
}, getDockedComponent:function (a) {
    if (Ext.isObject(a)) {
        a = a.getItemId()
    }
    return this.dockedItems.get(a)
}, getComponent:function (a) {
    var b = Ext.lib.Panel.superclass.getComponent.call(this, a);
    if (b == undefined) {
        b = this.getDockedComponent(a)
    }
    return b
}, initBodyStyles:function () {
    var a = Ext.isString(this.bodyStyle) ? this.bodyStyle.split(";") : [], b = Ext.Element;
    if (this.bodyPadding != undefined) {
        a.push("padding: " + b.unitizeBox((this.bodyPadding === true) ? 5 : this.bodyPadding))
    }
    if (this.bodyMargin != undefined) {
        a.push("margin: " + b.unitizeBox((this.bodyMargin === true) ? 5 : this.bodyMargin))
    }
    if (this.bodyBorder != undefined) {
        a.push("border-width: " + b.unitizeBox((this.bodyBorder === true) ? 1 : this.bodyBorder))
    }
    delete this.bodyStyle;
    return a.length ? a.join(";") : undefined
}, initRenderData:function () {
    return Ext.applyIf(Ext.lib.Panel.superclass.initRenderData.call(this), {bodyStyle:this.initBodyStyles(), bodyCls:this.bodyCls})
}, addDocked:function (a, e) {
    a = this.prepareItems(a);
    var d, b, c;
    for (b = 0, c = a.length; b < c; b++) {
        d = a[b];
        d.dock = d.dock || "top";
        if (e !== undefined) {
            this.dockedItems.insert(e + b, d)
        } else {
            this.dockedItems.add(d)
        }
        d.onAdded(this, b);
        this.onDockedAdd(d)
    }
    if (this.rendered) {
        this.doComponentLayout()
    }
}, onDockedAdd:Ext.emptyFn, onDockedRemove:Ext.emptyFn, insertDocked:function (b, a) {
    this.addDocked(a, b)
}, removeDocked:function (d, b) {
    if (!this.dockedItems.contains(d)) {
        return d
    }
    var c = this.componentLayout, a = c && this.rendered;
    if (a) {
        c.onRemove(d)
    }
    this.dockedItems.remove(d);
    d.onRemoved();
    this.onDockedRemove(d);
    if (b === true || (b !== false && this.autoDestroy)) {
        d.destroy()
    }
    if (a && !b) {
        c.afterRemove(d)
    }
    this.doComponentLayout();
    return d
}, getDockedItems:function () {
    if (this.dockedItems && this.dockedItems.items.length) {
        return this.dockedItems.items.slice()
    }
    return[]
}, getTargetEl:function () {
    return this.body
}, getRefItems:function (a) {
    var f = Ext.lib.Panel.superclass.getRefItems.call(this, a), c = this.getDockedItems(), e = c.length, b = 0, d;
    f = f.concat(c);
    if (a) {
        for (; b < e; b++) {
            d = c[b];
            if (d.getRefItems) {
                f = f.concat(d.getRefItems(true))
            }
        }
    }
    return f
}, beforeDestroy:function () {
    var b = this.dockedItems, a;
    if (b) {
        while ((a = b.first())) {
            this.removeDocked(a, true)
        }
    }
    Ext.lib.Panel.superclass.beforeDestroy.call(this)
}});
Ext.Panel = Ext.extend(Ext.lib.Panel, {});
Ext.reg("panel", Ext.Panel);
Ext.Panel = Ext.extend(Ext.lib.Panel, {scroll:false});
Ext.reg("panel", Ext.Panel);
Ext.Button = Ext.extend(Ext.Component, {initComponent:function () {
    this.addEvents("tap", "beforetap");
    Ext.Button.superclass.initComponent.call(this);
    this.createAutoHandler()
}, iconAlign:"left", baseCls:"x-button", pressedCls:"x-button-pressed", badgeText:"", badgeCls:"x-badge", hasBadgeCls:"x-hasbadge", labelCls:"x-button-label", ui:"normal", isButton:true, pressedDelay:0, iconMaskCls:"x-icon-mask", iconMask:false, afterRender:function (c, a) {
    var e = this;
    Ext.Button.superclass.afterRender.call(e, c, a);
    var g = e.text, d = e.icon, b = e.iconCls, f = e.badgeText;
    e.text = e.icon = e.iconCls = e.badgeText = null;
    e.setText(g);
    e.setIcon(d);
    e.setIconClass(b);
    if (e.iconMask && e.iconEl) {
        e.iconEl.addCls(e.iconMaskCls)
    }
    e.setBadge(f)
}, initEvents:function () {
    var a = this;
    Ext.Button.superclass.initEvents.call(a);
    a.mon(a.el, {scope:a, tap:a.onPress, tapstart:a.onTapStart, tapcancel:a.onTapCancel})
}, onTapStart:function () {
    var a = this;
    if (!a.disabled) {
        if (a.pressedDelay) {
            a.pressedTimeout = setTimeout(function () {
                a.el.addCls(a.pressedCls)
            }, Ext.isNumber(a.pressedDelay) ? a.pressedDelay : 100)
        } else {
            a.el.addCls(a.pressedCls)
        }
    }
}, onTapCancel:function () {
    var a = this;
    if (a.pressedTimeout) {
        clearTimeout(a.pressedTimeout);
        delete a.pressedTimeout
    }
    a.el.removeCls(a.pressedCls)
}, setHandler:function (b, a) {
    this.handler = b;
    this.scope = a;
    return this
}, setText:function (b) {
    var a = this;
    if (a.rendered) {
        if (!a.textEl && b) {
            a.textEl = a.el.createChild({tag:"span", html:b, cls:this.labelCls})
        } else {
            if (a.textEl && b != a.text) {
                if (b) {
                    a.textEl.setHTML(b)
                } else {
                    a.textEl.remove();
                    a.textEl = null
                }
            }
        }
    }
    a.text = b;
    return a
}, setIcon:function (a) {
    var b = this;
    if (b.rendered) {
        if (!b.iconEl && a) {
            b.iconEl = b.el.createChild({tag:"img", src:Ext.BLANK_IMAGE_URL, style:"background-image: " + (a ? "url(" + a + ")" : "")});
            b.setIconAlign(b.iconAlign)
        } else {
            if (b.iconEl && a != b.icon) {
                if (a) {
                    b.iconEl.setStyle("background-image", a ? "url(" + a + ")" : "");
                    b.setIconAlign(b.iconAlign)
                } else {
                    b.setIconAlign(false);
                    b.iconEl.remove();
                    b.iconEl = null
                }
            }
        }
    }
    b.icon = a;
    return b
}, setIconClass:function (a) {
    var b = this;
    if (b.rendered) {
        if (!b.iconEl && a) {
            b.iconEl = b.el.createChild({tag:"img", src:Ext.BLANK_IMAGE_URL, cls:a});
            b.setIconAlign(b.iconAlign)
        } else {
            if (b.iconEl && a != b.iconCls) {
                if (a) {
                    if (b.iconCls) {
                        b.iconEl.removeCls(b.iconCls)
                    }
                    b.iconEl.addCls(a);
                    b.setIconAlign(b.iconAlign)
                } else {
                    b.setIconAlign(false);
                    b.iconEl.remove();
                    b.iconEl = null
                }
            }
        }
    }
    b.iconCls = a;
    return b
}, setIconAlign:function (d) {
    var c = this, a = ["top", "right", "bottom", "left"], d = ((a.indexOf(d) == -1 || !d) && d !== false) ? c.iconAlign : d, b;
    if (c.rendered && c.iconEl) {
        c.el.removeCls("x-iconalign-" + c.iconAlign);
        if (d) {
            c.el.addCls("x-iconalign-" + d)
        }
    }
    c.iconAlign = (d === false) ? c.iconAlign : d;
    return c
}, setBadge:function (b) {
    var a = this;
    if (a.rendered) {
        if (!a.badgeEl && b) {
            a.badgeEl = a.el.createChild({tag:"span", cls:a.badgeCls, html:b});
            a.el.addCls(a.hasBadgeCls)
        } else {
            if (a.badgeEl && b != a.badgeText) {
                if (b) {
                    a.badgeEl.setHTML(b);
                    a.el.addCls(a.hasBadgeCls)
                } else {
                    a.badgeEl.remove();
                    a.badgeEl = null;
                    a.el.removeCls(a.hasBadgeCls)
                }
            }
        }
    }
    a.badgeText = b;
    return a
}, getText:function () {
    return this.text
}, getBadgeText:function () {
    return this.badgeText
}, onDisable:function () {
    this.onDisableChange(true)
}, onEnable:function () {
    this.onDisableChange(false)
}, onDisableChange:function (a) {
    var b = this;
    if (b.el) {
        b.el[a ? "addCls" : "removeCls"](b.disabledCls);
        b.el.dom.disabled = a
    }
    b.disabled = a
}, onPress:function (b) {
    var a = this;
    if (!a.disabled && this.fireEvent("beforetap") !== false) {
        setTimeout(function () {
            if (!a.preventCancel) {
                a.onTapCancel()
            }
            a.callHandler(b);
            a.fireEvent("tap", a, b)
        }, 10)
    }
}, callHandler:function (b) {
    var a = this;
    if (a.handler) {
        a.handler.call(a.scope || a, a, b)
    }
}, createAutoHandler:function () {
    var a = this, b = a.autoEvent;
    if (b) {
        if (typeof b == "string") {
            b = {name:b, scope:a.scope || a}
        }
        a.addEvents(b.name);
        a.setHandler(function () {
            b.scope.fireEvent(b.name, b.scope, a)
        }, b.scope)
    }
}});
Ext.reg("button", Ext.Button);
Ext.SegmentedButton = Ext.extend(Ext.Container, {defaultType:"button", componentCls:"x-segmentedbutton", pressedCls:"x-button-pressed", allowMultiple:false, initComponent:function () {
    this.layout = Ext.apply({}, this.layout || {}, {type:"hbox", align:"stretch"});
    Ext.SegmentedButton.superclass.initComponent.call(this);
    if (this.allowDepress === undefined) {
        this.allowDepress = this.allowMultiple
    }
    this.addEvents("toggle")
}, initEvents:function () {
    Ext.SegmentedButton.superclass.initEvents.call(this);
    this.mon(this.el, {tap:this.onTap, capture:true, scope:this})
}, afterLayout:function (b) {
    var a = this;
    Ext.SegmentedButton.superclass.afterLayout.call(a, b);
    if (!a.initialized) {
        a.items.each(function (d, c) {
            a.setPressed(d, !!d.pressed, true)
        });
        if (a.allowMultiple) {
            a.pressedButtons = a.getPressedButtons()
        }
        a.initialized = true
    }
}, onTap:function (b, a) {
    if (!this.disabled && (a = b.getTarget(".x-button"))) {
        this.setPressed(a.id, this.allowDepress ? undefined : true)
    }
}, getPressed:function () {
    return this.allowMultiple ? this.getPressedButtons() : this.pressedButton
}, setPressed:function (a, d, b) {
    var c = this;
    a = c.getComponent(a);
    if (!a || !a.isButton || a.disabled) {
        if (!c.allowMultiple && c.pressedButton) {
            c.setPressed(c.pressedButton, false)
        }
        return
    }
    if (!Ext.isBoolean(d)) {
        d = !a.pressed
    }
    if (d) {
        if (!c.allowMultiple) {
            if (c.pressedButton && c.pressedButton !== a) {
                c.pressedButton.el.removeCls(c.pressedCls);
                c.pressedButton.pressed = false;
                if (b !== true) {
                    c.fireEvent("toggle", c, c.pressedButton, false)
                }
            }
            c.pressedButton = a
        }
        a.el.addCls(c.pressedCls);
        a.pressed = true;
        a.preventCancel = true;
        if (c.initialized && b !== true) {
            c.fireEvent("toggle", c, a, true)
        }
    } else {
        if (!d) {
            if (!c.allowMultiple && a === c.pressedButton) {
                c.pressedButton = null
            }
            if (a.pressed) {
                a.el.removeCls(c.pressedCls);
                a.pressed = false;
                if (b !== true) {
                    c.fireEvent("toggle", c, a, false)
                }
            }
        }
    }
    if (c.allowMultiple && c.initialized) {
        c.pressedButtons = c.getPressedButtons()
    }
}, getPressedButtons:function (b) {
    var a = this.items.filterBy(function (c) {
        return c.isButton && !c.disabled && c.pressed
    });
    return a.items
}, disable:function () {
    this.items.each(function (a) {
        a.disable()
    });
    Ext.SegmentedButton.superclass.disable.apply(this, arguments)
}, enable:function () {
    this.items.each(function (a) {
        a.enable()
    }, this);
    Ext.SegmentedButton.superclass.enable.apply(this, arguments)
}});
Ext.reg("segmentedbutton", Ext.SegmentedButton);
Ext.AbstractStoreSelectionModel = Ext.extend(Ext.util.Observable, {allowDeselect:false, selected:null, constructor:function (a) {
    a = a || {};
    Ext.apply(this, a);
    this.modes = {SINGLE:true, SIMPLE:true, MULTI:true};
    this.setSelectionMode(a.mode);
    this.selected = new Ext.util.MixedCollection();
    Ext.AbstractStoreSelectionModel.superclass.constructor.call(this, a)
}, bind:function (a, b) {
    if (!b && this.store) {
        if (a !== this.store && this.store.autoDestroy) {
            this.store.destroy()
        } else {
            this.store.un("add", this.onStoreAdd, this);
            this.store.un("clear", this.onStoreClear, this);
            this.store.un("remove", this.onStoreRemove, this);
            this.store.un("update", this.onStoreUpdate, this)
        }
    }
    if (a) {
        a = Ext.StoreMgr.lookup(a);
        a.on({add:this.onStoreAdd, clear:this.onStoreClear, remove:this.onStoreRemove, update:this.onStoreUpdate, scope:this})
    }
    this.store = a;
    if (a && !b) {
        this.refresh()
    }
}, selectAll:function (a) {
    var c = this.store.getRange();
    for (var b = 0, d = c.length; b < d; b++) {
        this.doSelect(c[b], true, a)
    }
}, deselectAll:function () {
    var b = this.getSelection();
    for (var a = 0, c = b.length; a < c; a++) {
        this.doDeselect(b[a])
    }
}, selectWithEvent:function (a, b) {
    switch (this.selectionMode) {
        case"MULTI":
            if (b.ctrlKey && this.isSelected(a)) {
                this.doDeselect(a, false)
            } else {
                if (b.shiftKey && this.lastFocused) {
                    this.selectRange(this.lastFocused, a, b.ctrlKey)
                } else {
                    if (b.ctrlKey) {
                        this.doSelect(a, true, false)
                    } else {
                        if (this.isSelected(a) && !b.shiftKey && !b.ctrlKey && this.selected.getCount() > 1) {
                            this.doSelect(a, false, false)
                        } else {
                            this.doSelect(a, false)
                        }
                    }
                }
            }
            break;
        case"SIMPLE":
            if (this.isSelected(a)) {
                this.doDeselect(a)
            } else {
                this.doSelect(a, true)
            }
            break;
        case"SINGLE":
            if (this.allowDeselect && this.isSelected(a)) {
                this.doDeselect(a)
            } else {
                this.doSelect(a, false)
            }
            break
    }
}, selectRange:function (g, h, k, b) {
    var e, j = this.store.indexOf(g), d = this.store.indexOf(h), f, c = 0, a;
    if (this.isLocked()) {
        return
    }
    if (j > d) {
        f = d;
        d = j;
        j = f
    }
    for (e = j; e <= d; e++) {
        if (this.isSelected(this.store.getAt(e))) {
            c++
        }
    }
    if (!b) {
        a = -1
    } else {
        a = (b == "up") ? j : d
    }
    for (e = j; e <= d; e++) {
        if (c == (d - j + 1)) {
            if (e != a) {
                this.doDeselect(e, true)
            }
        } else {
            this.doSelect(e, true)
        }
    }
}, select:function (b, c, a) {
    this.doSelect(b, c, a)
}, deselect:function (b, a) {
    this.doDeselect(b, a)
}, doSelect:function (c, d, b) {
    if (this.locked) {
        return
    }
    if (typeof c === "number") {
        c = [this.store.getAt(c)]
    }
    if (this.selectionMode == "SINGLE" && c) {
        var a = c.length ? c[0] : c;
        this.doSingleSelect(a, b)
    } else {
        this.doMultiSelect(c, d, b)
    }
}, doMultiSelect:function (c, g, b) {
    if (this.locked) {
        return
    }
    var e = this.selected, h = false, a;
    c = !Ext.isArray(c) ? [c] : c;
    if (!g && e.getCount() > 0) {
        h = true;
        this.doDeselect(this.getSelection(), true)
    }
    for (var d = 0, f = c.length; d < f; d++) {
        a = c[d];
        if (g && this.isSelected(a)) {
            continue
        }
        h = true;
        this.lastSelected = a;
        e.add(a);
        if (!b) {
            this.setLastFocused(a)
        }
        this.onSelectChange(a, true, b)
    }
    this.maybeFireSelectionChange(h && !b)
}, doDeselect:function (c, b) {
    if (this.locked) {
        return
    }
    if (typeof c === "number") {
        c = [this.store.getAt(c)]
    }
    var g = false, e = this.selected, a;
    c = !Ext.isArray(c) ? [c] : c;
    for (var d = 0, f = c.length; d < f; d++) {
        a = c[d];
        if (e.remove(a)) {
            if (this.lastSelected == a) {
                this.lastSelected = e.last()
            }
            this.onSelectChange(a, false, b);
            g = true
        }
    }
    this.maybeFireSelectionChange(g && !b)
}, doSingleSelect:function (a, b) {
    if (this.locked) {
        return
    }
    if (this.isSelected(a)) {
        return
    }
    var c = this.selected;
    if (c.getCount() > 0) {
        this.doDeselect(this.lastSelected, b)
    }
    c.add(a);
    this.lastSelected = a;
    this.onSelectChange(a, true, b);
    this.setLastFocused(a);
    this.maybeFireSelectionChange(!b)
}, setLastFocused:function (b) {
    var a = this.lastFocused;
    this.lastFocused = b;
    this.onLastFocusChanged(a, b)
}, maybeFireSelectionChange:function (a) {
    if (a) {
        this.fireEvent("selectionchange", this, this.getSelection())
    }
}, getLastSelected:function () {
    return this.lastSelected
}, getLastFocused:function () {
    return this.lastFocused
}, getSelection:function () {
    return this.selected.getRange()
}, getSelectionMode:function () {
    return this.selectionMode
}, setSelectionMode:function (a) {
    a = a ? a.toUpperCase() : "SINGLE";
    this.selectionMode = this.modes[a] ? a : "SINGLE"
}, isLocked:function () {
    return this.locked
}, setLocked:function (a) {
    this.locked = !!a
}, isSelected:function (a) {
    a = Ext.isNumber(a) ? this.store.getAt(a) : a;
    return this.selected.indexOf(a) !== -1
}, hasSelection:function () {
    return this.selected.getCount() > 0
}, refresh:function () {
    var a = [], e = this.getSelection(), d = e.length, c, f, b = 0;
    for (; b < d; b++) {
        c = e[b];
        if (this.store.indexOf(c) != -1) {
            a.push(c)
        }
    }
    if (this.selected.getCount() != a.length) {
        f = true
    }
    this.clearSelections();
    if (a.length) {
        this.doSelect(a, false, true)
    }
    this.maybeFireSelectionChange(f)
}, clearSelections:function () {
    this.selected.clear();
    this.lastSelected = null;
    this.setLastFocused(null)
}, onStoreAdd:function () {
}, onStoreClear:function () {
    var a = this.selected;
    if (a.getCount > 0) {
        a.clear();
        this.lastSelected = null;
        this.setLastFocused(null);
        this.maybeFireSelectionChange(true)
    }
}, onStoreRemove:function (b, a) {
    if (this.locked) {
        return
    }
    var c = this.selected;
    if (c.remove(a)) {
        if (this.lastSelected == a) {
            this.lastSelected = null
        }
        if (this.getLastFocused() == a) {
            this.setLastFocused(null)
        }
        this.maybeFireSelectionChange(true)
    }
}, getCount:function () {
    return this.selected.getCount()
}, destroy:function () {
}, onStoreUpdate:function () {
}, onSelectChange:function (a, c, b) {
}, onLastFocusChanged:function (b, a) {
}, onEditorKey:function (b, a) {
}, bindComponent:function (a) {
}});
Ext.DataViewSelectionModel = Ext.extend(Ext.AbstractStoreSelectionModel, {deselectOnContainerClick:true, bindComponent:function (a) {
    this.view = a;
    this.bind(a.getStore());
    var b = {refresh:this.refresh, scope:this, el:{scope:this}};
    b.el[a.triggerEvent] = this.onItemClick;
    b.el[a.triggerCtEvent] = this.onContainerClick;
    a.on(b)
}, onItemClick:function (c) {
    var a = this.view, b = a.findTargetByEvent(c);
    if (b) {
        this.selectWithEvent(a.getRecord(b), c)
    } else {
        return false
    }
}, onContainerClick:function () {
    if (this.deselectOnContainerClick) {
        this.deselectAll()
    }
}, onSelectChange:function (b, d, c) {
    var a = this.view;
    if (d) {
        a.onItemSelect(b);
        if (!c) {
            this.fireEvent("select", this, b)
        }
    } else {
        a.onItemDeselect(b);
        if (!c) {
            this.fireEvent("deselect", this, b)
        }
    }
}});
Ext.DataView = Ext.extend(Ext.Component, {loadingText:"Loading...", selectedItemCls:"x-item-selected", emptyText:"", deferEmptyText:true, trackOver:false, blockRefresh:false, last:false, triggerEvent:"click", triggerCtEvent:"containerclick", addCmpEvents:function () {
}, initComponent:function () {
    var a = Ext.isDefined;
    if (!a(this.tpl) || !a(this.store) || !a(this.itemSelector)) {
        throw"DataView requires tpl, store and itemSelector configurations to be defined."
    }
    Ext.DataView.superclass.initComponent.call(this);
    if (Ext.isString(this.tpl) || Ext.isArray(this.tpl)) {
        this.tpl = new Ext.XTemplate(this.tpl)
    }
    if (Ext.isDefined(this.overCls) || Ext.isDefined(this.overClass)) {
        this.overItemCls = this.overCls || this.overClass;
        delete this.overCls;
        delete this.overClass;
        throw"Using the deprecated overCls or overClass configuration. Use overItemCls."
    }
    if (Ext.isDefined(this.selectedCls) || Ext.isDefined(this.selectedClass)) {
        this.selectedItemCls = this.selectedCls || this.selectedClass;
        delete this.selectedCls;
        delete this.selectedClass;
        throw"Using the deprecated selectedCls or selectedClass configuration. Use selectedItemCls."
    }
    this.addEvents("beforerefresh", "refresh");
    this.addCmpEvents();
    this.store = Ext.StoreMgr.lookup(this.store);
    this.all = new Ext.CompositeElementLite();
    this.getSelectionModel().bindComponent(this)
}, onRender:function () {
    Ext.DataView.superclass.onRender.apply(this, arguments);
    if (this.loadingText) {
        this.loadMask = new Ext.LoadMask(this.el, {msg:this.loadingText})
    }
}, getSelectionModel:function () {
    if (!this.selModel) {
        this.selModel = {}
    }
    var a;
    switch (true) {
        case this.simpleSelect:
            a = "SIMPLE";
            break;
        case this.multiSelect:
            a = "MULTI";
            break;
        case this.singleSelect:
        default:
            a = "SINGLE";
            break
    }
    Ext.applyIf(this.selModel, {allowDeselect:this.allowDeselect, mode:a});
    if (!this.selModel.events) {
        this.selModel = new Ext.DataViewSelectionModel(this.selModel)
    }
    if (!this.selModel.hasRelaySetup) {
        this.relayEvents(this.selModel, ["selectionchange", "select", "deselect"]);
        this.selModel.hasRelaySetup = true
    }
    if (this.disableSelection) {
        this.selModel.locked = true
    }
    return this.selModel
}, refresh:function () {
    if (!this.rendered) {
        return
    }
    this.fireEvent("beforerefresh", this);
    var b = this.getTargetEl(), a = this.store.getRange();
    b.update("");
    if (a.length < 1) {
        if (!this.deferEmptyText || this.hasSkippedEmptyText) {
            b.update(this.emptyText)
        }
        this.all.clear()
    } else {
        this.tpl.overwrite(b, this.collectData(a, 0));
        this.all.fill(Ext.query(this.itemSelector, b.dom));
        this.updateIndexes(0)
    }
    this.hasSkippedEmptyText = true;
    this.fireEvent("refresh", this)
}, prepareData:function (c, b, a) {
    if (a) {
        Ext.apply(c, this.prepareAssociatedData(a))
    }
    return c
}, prepareAssociatedData:function (m, b) {
    b = b || [];
    var g = m.associations.items, k = g.length, d = {}, e, a, f, o, p, c, n, l, h;
    for (l = 0; l < k; l++) {
        c = g[l];
        e = m[c.storeName];
        d[c.name] = [];
        if (e && e.data.length > 0) {
            f = e.data.items;
            p = f.length;
            for (h = 0; h < p; h++) {
                o = f[h];
                n = o.internalId;
                if (b.indexOf(n) == -1) {
                    b.push(n);
                    d[c.name][h] = o.data;
                    Ext.apply(d[c.name][h], this.prepareAssociatedData(o, b))
                }
            }
        }
    }
    return d
}, collectData:function (b, e) {
    var d = [], c = 0, a = b.length;
    for (; c < a; c++) {
        d[d.length] = this.prepareData(b[c].data, e + c, b[c])
    }
    return d
}, bufferRender:function (a, b) {
    var c = document.createElement("div");
    this.tpl.overwrite(c, this.collectData(a, b));
    return Ext.query(this.itemSelector, c)
}, onUpdate:function (e, a) {
    var b = this.store.indexOf(a), c, d;
    if (b > -1) {
        c = this.all.elements[b];
        d = this.bufferRender([a], b)[0];
        this.all.replaceElement(b, d, true);
        this.updateIndexes(b, b);
        this.selModel.refresh()
    }
}, onAdd:function (f, d, e) {
    if (this.all.getCount() === 0) {
        this.refresh();
        return
    }
    var c = this.bufferRender(d, e), g, b = this.all.elements;
    if (e < this.all.getCount()) {
        g = this.all.item(e).insertSibling(c, "before", true);
        b.splice.apply(b, [e, 0].concat(c))
    } else {
        g = this.all.last().insertSibling(c, "after", true);
        b.push.apply(b, c)
    }
    this.updateIndexes(e)
}, onRemove:function (c, a, b) {
    this.all.removeElement(b, true);
    this.updateIndexes(b);
    if (this.store.getCount() === 0) {
        this.refresh()
    }
}, refreshNode:function (a) {
    this.onUpdate(this.store, this.store.getAt(a))
}, updateIndexes:function (d, c) {
    var b = this.all.elements;
    d = d || 0;
    c = c || ((c === 0) ? 0 : (b.length - 1));
    for (var a = d; a <= c; a++) {
        b[a].viewIndex = a
    }
}, getStore:function () {
    return this.store
}, bindStore:function (a, b) {
    if (!b && this.store) {
        if (a !== this.store && this.store.autoDestroy) {
            this.store.destroy()
        } else {
            this.mun(this.store, {scope:this, beforeload:this.onBeforeLoad, datachanged:this.onDataChanged, add:this.onAdd, remove:this.onRemove, update:this.onUpdate, clear:this.refresh})
        }
        if (!a) {
            if (this.loadMask) {
                this.loadMask.bindStore(null)
            }
            this.store = null
        }
    }
    if (a) {
        a = Ext.StoreMgr.lookup(a);
        this.mon(a, {scope:this, beforeload:this.onBeforeLoad, datachanged:this.onDataChanged, add:this.onAdd, remove:this.onRemove, update:this.onUpdate, clear:this.refresh});
        if (this.loadMask) {
            this.loadMask.bindStore(a)
        }
    }
    this.store = a;
    this.getSelectionModel().bind(a);
    if (a) {
        this.refresh()
    }
}, onDataChanged:function () {
    if (this.blockRefresh !== true) {
        this.refresh.apply(this, arguments)
    }
}, findItemByChild:function (a) {
    return Ext.fly(a).findParent(this.itemSelector, this.getTargetEl())
}, findTargetByEvent:function (a) {
    return a.getTarget(this.itemSelector, this.getTargetEl())
}, getSelectedNodes:function () {
    var b = [], a = this.selModel.getSelection(), d = a.length, c = 0;
    for (; c < d; c++) {
        b.push(this.getNode(a[c]))
    }
    return b
}, getRecords:function (c) {
    var b = [], d = 0, a = c.length;
    for (; d < a; d++) {
        b[b.length] = this.store.getAt(c[d].viewIndex)
    }
    return r
}, getRecord:function (a) {
    return this.store.getAt(a.viewIndex)
}, isSelected:function (b) {
    var a = this.getRecord(b);
    return this.selModel.isSelected(a)
}, select:function (b, c, a) {
    this.selModel.select(b, c, a)
}, deselect:function (b, a) {
    this.selModel.deselect(b, a)
}, getNode:function (b) {
    if (Ext.isString(b)) {
        return document.getElementById(b)
    } else {
        if (Ext.isNumber(b)) {
            return this.all.elements[b]
        } else {
            if (b instanceof Ext.data.Model) {
                var a = this.store.indexOf(b);
                return this.all.elements[a]
            }
        }
    }
    return b
}, getNodes:function (e, a) {
    var d = this.all.elements, b = [], c;
    e = e || 0;
    a = !Ext.isDefined(a) ? Math.max(d.length - 1, 0) : a;
    if (e <= a) {
        for (c = e; c <= a && d[c]; c++) {
            b.push(d[c])
        }
    } else {
        for (c = e; c >= a && d[c]; c--) {
            b.push(d[c])
        }
    }
    return b
}, indexOf:function (a) {
    a = this.getNode(a);
    if (Ext.isNumber(a.viewIndex)) {
        return a.viewIndex
    }
    return this.all.indexOf(a)
}, onBeforeLoad:function () {
    if (this.loadingText) {
        this.getTargetEl().update("");
        this.all.clear()
    }
}, onDestroy:function () {
    this.all.clear();
    Ext.DataView.superclass.onDestroy.call(this);
    this.bindStore(null);
    this.selModel.destroy()
}, onItemSelect:function (a) {
    var b = this.getNode(a);
    Ext.fly(b).addCls(this.selectedItemCls)
}, onItemDeselect:function (a) {
    var b = this.getNode(a);
    Ext.fly(b).removeCls(this.selectedItemCls)
}, select:function (a, b, d) {
    console.warn("DataView: select will be removed, please access select through a DataView's SelectionModel, ie: view.getSelectionModel().select()");
    var c = this.getSelectionModel();
    return c.select.apply(c, arguments)
}, clearSelections:function () {
    console.warn("DataView: clearSelections will be removed, please access deselectAll through DataView's SelectionModel, ie: view.getSelectionModel().deselectAll()");
    var a = this.getSelectionModel();
    return a.deselectAll()
}});
Ext.reg("dataview", Ext.DataView);
Ext.DataView.override({getSelectionCount:function () {
    return this.selModel.getSelection().length
}, getSelectedRecords:function () {
    return this.selModel.getSelection()
}});
Ext.DataView.override({scroll:"vertical", pressedCls:"x-item-pressed", pressedDelay:100, allowDeselect:true, triggerEvent:"singletap", triggerCtEvent:"containertap", addCmpEvents:function () {
    this.addEvents("itemtap", "itemdoubletap", "itemswipe", "containertap", "selectionchange", "beforeselect")
}, afterRender:function () {
    var a = this;
    Ext.DataView.superclass.afterRender.call(a);
    var b = {tapstart:a.onTapStart, tapcancel:a.onTapCancel, touchend:a.onTapCancel, doubletap:a.onDoubleTap, swipe:a.onSwipe, scope:a};
    b[this.triggerEvent] = a.onTap;
    a.mon(a.getTargetEl(), b);
    if (this.store) {
        this.bindStore(this.store, true)
    }
}, onTap:function (c) {
    var b = this.findTargetByEvent(c);
    if (b) {
        Ext.fly(b).removeCls(this.pressedCls);
        var a = this.indexOf(b);
        if (this.onItemTap(b, a, c) !== false) {
            this.fireEvent("itemtap", this, a, b, c)
        }
    } else {
        if (this.fireEvent("containertap", this, c) !== false) {
            this.onContainerTap(c)
        }
    }
}, onTapStart:function (d, a) {
    var c = this, b = this.findTargetByEvent(d);
    if (b) {
        if (c.pressedDelay) {
            if (c.pressedTimeout) {
                clearTimeout(c.pressedTimeout)
            }
            c.pressedTimeout = setTimeout(function () {
                Ext.fly(b).addCls(c.pressedCls)
            }, Ext.isNumber(c.pressedDelay) ? c.pressedDelay : 100)
        } else {
            Ext.fly(b).addCls(c.pressedCls)
        }
    }
}, onTapCancel:function (d, a) {
    var c = this, b = this.findTargetByEvent(d);
    if (c.pressedTimeout) {
        clearTimeout(c.pressedTimeout);
        delete c.pressedTimeout
    }
    if (b) {
        Ext.fly(b).removeCls(c.pressedCls)
    }
}, onContainerTap:function (a) {
}, onDoubleTap:function (b) {
    var a = this.findTargetByEvent(b);
    if (a) {
        this.fireEvent("itemdoubletap", this, this.indexOf(a), a, b)
    }
}, onSwipe:function (b) {
    var a = this.findTargetByEvent(b);
    if (a) {
        this.fireEvent("itemswipe", this, this.indexOf(a), a, b)
    }
}, onItemTap:function (b, a, c) {
    if (this.pressedTimeout) {
        clearTimeout(this.pressedTimeout);
        delete this.pressedTimeout
    }
    return true
}});
Ext.List = Ext.extend(Ext.DataView, {componentCls:"x-list", pinHeaders:Ext.is.iOS || Ext.is.Desktop, indexBar:false, grouped:false, clearSelectionOnDeactivate:true, renderTpl:['<tpl if="grouped"><h3 class="x-list-header x-list-header-swap x-hidden-display"></h3></tpl>'], groupTpl:['<tpl for=".">', '<div class="x-list-group x-group-{id}">', '<h3 class="x-list-header">{group}</h3>', '<div class="x-list-group-items">', "{items}", "</div>", "</div>", "</tpl>"], itemSelector:".x-list-item", itemCls:"", onItemDisclosure:false, preventSelectionOnDisclose:true, initComponent:function () {
    var a = {};
    if (Ext.isArray(this.itemTpl)) {
        this.itemTpl = this.itemTpl.join("")
    } else {
        if (this.itemTpl && this.itemTpl.html) {
            Ext.apply(a, this.itemTpl.initialConfig);
            this.itemTpl = this.itemTpl.html
        }
    }
    if (!Ext.isDefined(this.itemTpl)) {
        throw new Error("Ext.List: itemTpl is a required configuration.")
    }
    if (this.itemTpl && this.itemTpl.indexOf('"x-list-item"') !== -1) {
        throw new Error("Ext.List: Using a CSS class of x-list-item within your own tpl will break Ext.Lists. Remove the x-list-item from the tpl/itemTpl")
    }
    this.tpl = '<tpl for="."><div class="x-list-item ' + this.itemCls + '"><div class="x-list-item-body">' + this.itemTpl + "</div>";
    if (this.onItemDisclosure) {
        this.tpl += '<div class="x-list-disclosure"></div>'
    }
    this.tpl += "</div></tpl>";
    this.tpl = new Ext.XTemplate(this.tpl, a);
    if (this.grouped) {
        this.listItemTpl = this.tpl;
        if (Ext.isString(this.listItemTpl) || Ext.isArray(this.listItemTpl)) {
            this.listItemTpl = new Ext.XTemplate(this.listItemTpl, a)
        }
        if (Ext.isString(this.groupTpl) || Ext.isArray(this.groupTpl)) {
            this.tpl = new Ext.XTemplate(this.groupTpl)
        }
    } else {
        this.indexBar = false
    }
    if (this.scroll !== false) {
        this.scroll = {direction:"vertical", useIndicators:!this.indexBar}
    }
    Ext.List.superclass.initComponent.call(this);
    if (this.onItemDisclosure) {
        if (Ext.isFunction(this.onItemDisclosure)) {
            this.onItemDisclosure = {scope:this, handler:this.onItemDisclosure}
        }
    }
    this.on("deactivate", this.onDeactivate, this);
    this.addEvents("disclose", "update")
}, onRender:function () {
    if (this.grouped) {
        Ext.applyIf(this.renderData, {grouped:true});
        if (this.scroll) {
            Ext.applyIf(this.renderSelectors, {header:".x-list-header-swap"})
        }
    }
    Ext.List.superclass.onRender.apply(this, arguments)
}, onDeactivate:function () {
    if (this.clearSelectionOnDeactivate) {
        this.getSelectionModel().deselectAll()
    }
}, afterRender:function () {
    if (!this.grouped) {
        this.el.addCls("x-list-flat")
    }
    this.getTargetEl().addCls("x-list-parent");
    if (this.indexBar) {
        this.indexBar = new Ext.IndexBar(Ext.apply({}, Ext.isObject(this.indexBar) ? this.indexBar : {}, {xtype:"indexbar", alphabet:true, renderTo:this.el}));
        this.addCls("x-list-indexed")
    }
    Ext.List.superclass.afterRender.call(this);
    if (this.onItemDisclosure) {
        this.mon(this.getTargetEl(), "singletap", this.handleItemDisclosure, this, {delegate:".x-list-disclosure"})
    }
}, initEvents:function () {
    Ext.List.superclass.initEvents.call(this);
    if (this.grouped) {
        if (this.pinHeaders && this.scroll) {
            this.mon(this.scroller, {scrollstart:this.onScrollStart, scroll:this.onScroll, scope:this})
        }
        if (this.indexBar) {
            this.mon(this.indexBar, {index:this.onIndex, scope:this})
        }
    }
}, handleItemDisclosure:function (f, c) {
    var d = this.findItemByChild(c), a, b;
    if (d) {
        a = this.getRecord(d);
        b = this.indexOf(d);
        if (this.preventSelectionOnDisclose) {
            f.stopEvent()
        }
        this.fireEvent("disclose", a, d, b, f);
        if (Ext.isObject(this.onItemDisclosure) && this.onItemDisclosure.handler) {
            this.onItemDisclosure.handler.call(this, a, d, b)
        }
    }
}, setActiveGroup:function (b) {
    var a = this;
    if (b) {
        if (!a.activeGroup || a.activeGroup.header != b.header) {
            a.header.setHTML(b.header.getHTML());
            a.header.show()
        }
    } else {
        a.header.hide()
    }
    this.activeGroup = b
}, getClosestGroups:function (g) {
    if (!this.groupOffsets) {
        this.updateOffsets()
    }
    var a = this.groupOffsets, d = a.length, f, b, e, c;
    for (b = 0; b < d; b++) {
        f = a[b];
        if (f.offset > g.y) {
            c = f;
            break
        }
        e = f
    }
    return{current:e, next:c}
}, updateIndexes:function () {
    Ext.List.superclass.updateIndexes.apply(this, arguments);
    this.updateList()
}, afterComponentLayout:function () {
    Ext.List.superclass.afterComponentLayout.apply(this, arguments);
    this.updateList()
}, updateList:function () {
    this.fireEvent("update", this);
    this.updateOffsets()
}, updateOffsets:function () {
    if (this.grouped) {
        this.groupOffsets = [];
        var c = this.getTargetEl().query("h3.x-list-header"), b = c.length, d, a;
        for (a = 0; a < b; a++) {
            d = Ext.get(c[a]);
            d.setVisibilityMode(Ext.Element.VISIBILITY);
            this.groupOffsets.push({header:d, offset:d.dom.offsetTop})
        }
    }
}, onScrollStart:function () {
    var a = this.scroller.getOffset();
    this.closest = this.getClosestGroups(a);
    this.setActiveGroup(this.closest.current)
}, onScroll:function (a, d, c) {
    if (!this.closest) {
        this.closest = this.getClosestGroups(d)
    }
    if (!this.headerHeight) {
        this.headerHeight = this.header.getHeight()
    }
    if (d.y <= 0) {
        if (this.activeGroup) {
            this.setActiveGroup(false);
            this.closest.next = this.closest.current
        }
        return
    } else {
        if ((this.closest.next && d.y > this.closest.next.offset) || (d.y < this.closest.current.offset)) {
            this.closest = this.getClosestGroups(d);
            this.setActiveGroup(this.closest.current)
        }
    }
    if (this.closest.next && d.y > 0 && this.closest.next.offset - d.y <= this.headerHeight) {
        var b = this.headerHeight - (this.closest.next.offset - d.y);
        Ext.Element.cssTranslate(this.header, {x:0, y:-b});
        this.transformed = true
    } else {
        if (this.transformed) {
            this.header.setStyle("-webkit-transform", null);
            this.transformed = false
        }
    }
}, onIndex:function (e, g, f) {
    var k = e.get("key").toLowerCase(), c = this.store.getGroups(), h = c.length, j, d, b, a;
    for (d = 0; d < h; d++) {
        j = c[d];
        a = this.getGroupId(j);
        if (a == k || a > k) {
            b = a;
            break
        } else {
            b = a
        }
    }
    b = this.getTargetEl().down(".x-group-" + a);
    if (b) {
        this.scroller.scrollTo({x:0, y:b.getOffsetsTo(this.scrollEl)[1]}, false, null, true)
    }
}, getGroupId:function (a) {
    return a.name.toLowerCase()
}, collectData:function (e, l) {
    if (!this.grouped) {
        return Ext.List.superclass.collectData.call(this, e, l)
    }
    var g = [], d = this.store.getGroups(), h = d.length, b, a, j, k, f;
    for (f = 0, h = d.length; f < h; f++) {
        k = d[f];
        b = k.children;
        for (j = 0, a = b.length; j < a; j++) {
            b[j] = b[j].data
        }
        g.push({group:k.name, id:this.getGroupId(k), items:this.listItemTpl.apply(b)})
    }
    return g
}, onUpdate:function (b, a) {
    if (this.grouped) {
        this.refresh()
    } else {
        Ext.List.superclass.onUpdate.apply(this, arguments)
    }
}, onAdd:function (c, a, b) {
    if (this.grouped) {
        this.refresh()
    } else {
        Ext.List.superclass.onAdd.apply(this, arguments)
    }
}, onRemove:function (c, a, b) {
    if (this.grouped) {
        this.refresh()
    } else {
        Ext.List.superclass.onRemove.apply(this, arguments)
    }
}});
Ext.reg("list", Ext.List);
Ext.IndexBar = Ext.extend(Ext.DataView, {componentCls:"x-indexbar", direction:"vertical", tpl:'<tpl for="."><div class="x-indexbar-item">{value}</div></tpl>', itemSelector:"div.x-indexbar-item", letters:["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"], listPrefix:"", componentLayout:"autocomponent", scroll:false, initComponent:function () {
    this.componentLayout = this.getComponentLayout();
    if (!this.store) {
        this.store = new Ext.data.Store({model:"IndexBarModel"})
    }
    if (this.alphabet == true) {
        this.ui = this.ui || "alphabet"
    }
    if (this.direction == "horizontal") {
        this.horizontal = true
    } else {
        this.vertical = true
    }
    this.addEvents("index");
    Ext.apply(this.renderData, {componentCls:this.componentCls});
    Ext.apply(this.renderSelectors, {body:"." + this.componentCls + "-body"});
    Ext.IndexBar.superclass.initComponent.call(this)
}, renderTpl:['<div class="{componentCls}-body"></div>'], getTargetEl:function () {
    return this.body
}, afterRender:function () {
    Ext.IndexBar.superclass.afterRender.call(this);
    if (this.alphabet === true) {
        this.loadAlphabet()
    }
    if (this.vertical) {
        this.el.addCls(this.componentCls + "-vertical")
    } else {
        if (this.horizontal) {
            this.el.addCls(this.componentCls + "-horizontal")
        }
    }
}, loadAlphabet:function () {
    var e = this.letters, a = e.length, d = [], b, c;
    for (b = 0; b < a; b++) {
        c = e[b];
        d.push({key:c.toLowerCase(), value:c})
    }
    this.store.loadData(d)
}, refresh:function () {
    var b = this.getTargetEl(), a = this.store.getRange();
    b.update("");
    if (a.length < 1) {
        if (!this.deferEmptyText || this.hasSkippedEmptyText) {
            b.update(this.emptyText)
        }
        this.all.clear()
    } else {
        this.tpl.overwrite(b, this.collectData(a, 0));
        this.all.fill(Ext.query(this.itemSelector, b.dom));
        this.updateIndexes(0)
    }
    this.hasSkippedEmptyText = true;
    this.fireEvent("refresh")
}, collectData:function () {
    var a = Ext.IndexBar.superclass.collectData.apply(this, arguments);
    if (this.listPrefix.length > 0) {
        a.unshift({key:"", value:this.listPrefix})
    }
    return a
}, initEvents:function () {
    Ext.IndexBar.superclass.initEvents.call(this);
    this.mon(this.el, {touchstart:this.onTouchStart, touchend:this.onTouchEnd, touchmove:this.onTouchMove, scope:this})
}, onTouchStart:function (b, a) {
    b.stopEvent();
    this.el.addCls(this.componentCls + "-pressed");
    this.pageBox = this.el.getPageBox();
    this.onTouchMove(b)
}, onTouchEnd:function (b, a) {
    b.stopEvent();
    this.el.removeCls(this.componentCls + "-pressed")
}, onTouchMove:function (d) {
    d.stopPropagation();
    var a = Ext.util.Point.fromEvent(d), c, b, f = this.pageBox;
    if (!f) {
        f = this.pageBox = this.el.getPageBox()
    }
    if (this.vertical) {
        if (a.y > f.bottom || a.y < f.top) {
            return
        }
        c = Ext.Element.fromPoint(f.left + (f.width / 2), a.y)
    } else {
        if (this.horizontal) {
            if (a.x > f.right || a.x < f.left) {
                return
            }
            c = Ext.Element.fromPoint(a.x, f.top + (f.height / 2))
        }
    }
    if (c) {
        b = this.getRecord(c.dom);
        if (b) {
            this.fireEvent("index", b, c, this.indexOf(c))
        }
    }
}, isVertical:function () {
    return this.vertical
}, isHorizontal:function () {
    return this.horizontal
}});
Ext.reg("indexbar", Ext.IndexBar);
Ext.regModel("IndexBarModel", {fields:["key", "value"]});
Ext.Toolbar = Ext.extend(Ext.Container, {isToolbar:true, defaultType:"button", baseCls:"x-toolbar", titleCls:"x-toolbar-title", ui:"dark", layout:null, titleEl:null, initComponent:function () {
    this.layout = Ext.apply({}, this.layout || {}, {type:"hbox", align:"center"});
    Ext.Toolbar.superclass.initComponent.call(this)
}, afterRender:function () {
    Ext.Toolbar.superclass.afterRender.call(this);
    if (this.title) {
        this.titleEl = this.el.createChild({cls:this.titleCls, html:this.title})
    }
}, setTitle:function (a) {
    this.title = a;
    if (this.rendered) {
        if (!this.titleEl) {
            this.titleEl = this.el.createChild({cls:this.titleCls, html:this.title})
        }
        this.titleEl.setHTML(a)
    }
}, showTitle:function () {
    if (this.titleEl) {
        this.titleEl.show()
    }
}, hideTitle:function () {
    if (this.titleEl) {
        this.titleEl.hide()
    }
}});
Ext.reg("toolbar", Ext.Toolbar);
Ext.Spacer = Ext.extend(Ext.Component, {initComponent:function () {
    if (!this.width) {
        this.flex = 1
    }
    Ext.Spacer.superclass.initComponent.call(this)
}, onRender:function () {
    Ext.Spacer.superclass.onRender.apply(this, arguments);
    if (this.flex) {
        this.el.setStyle("-webkit-box-flex", this.flex)
    }
}});
Ext.reg("spacer", Ext.Spacer);
Ext.Sheet = Ext.extend(Ext.Panel, {baseCls:"x-sheet", centered:false, floating:true, modal:true, draggable:false, monitorOrientation:true, hidden:true, hideOnMaskTap:false, enter:"bottom", exit:"bottom", enterAnimation:"slide", exitAnimation:"slide", transitions:{bottom:"up", top:"down", right:"left", left:"right"}, animSheet:function (a) {
    var d = null, b = this, c = b.transitions, e = Ext.Anim.prototype.opposites || {};
    if (a && this[a]) {
        if (a == "enter") {
            d = (typeof b.enterAnimation == "string") ? {type:b.enterAnimation || "slide", direction:c[b.enter] || "up"} : b.enterAnimation
        } else {
            if (a == "exit") {
                d = (typeof b.exitAnimation == "string") ? {type:b.exitAnimation || "slide", direction:c[b.exit] || "down"} : b.exitAnimation
            }
        }
    }
    return d
}, orient:function (a, j, d) {
    if (!this.container || this.centered || !this.floating) {
        return this
    }
    var g = this, e = g.initialConfig || {}, k = {width:e.width, height:e.height}, i = {x:e.x, y:e.y}, c = g.el.getPageBox(), f, b = 0;
    if (g.container.dom == document.body) {
        f = {width:window.innerWidth, height:window.innerHeight};
        b = document.body.scrollTop
    } else {
        f = g.container.getPageBox()
    }
    f.centerY = f.height / 2;
    f.centerX = f.width / 2;
    if (i.x != undefined || i.y != undefined) {
        i.x = i.x || 0;
        i.y = i.y || 0
    } else {
        if (/^(bottom|top)/i.test(g.enter)) {
            k.width = g.stretchX ? f.width : Math.min(200, Math.max(k.width || c.width || f.width, f.width));
            k.height = Math.min(k.height || 0, f.height) || undefined;
            k = g.setSize(k).getSize();
            i.x = f.centerX - k.width / 2;
            i.y = g.enter == "top" ? 0 : f.height - k.height + b
        } else {
            if (/^(left|right)/i.test(g.enter)) {
                k.height = g.stretchY ? f.height : Math.min(200, Math.max(k.height || c.height || f.height, f.height));
                k.width = Math.min(k.width || 0, f.width) || undefined;
                k = g.setSize(k).getSize();
                i.y = 0;
                i.x = g.enter == "left" ? 0 : f.width - k.width
            }
        }
    }
    g.setPosition(i);
    return this
}, afterRender:function () {
    Ext.Sheet.superclass.afterRender.apply(this, arguments);
    this.el.setVisibilityMode(Ext.Element.OFFSETS)
}, onShow:function (a) {
    this.orient();
    return Ext.Sheet.superclass.onShow.call(this, a || this.animSheet("enter"))
}, onOrientationChange:function (b, a, c) {
    this.orient();
    Ext.Sheet.superclass.onOrientationChange.apply(this, arguments)
}, beforeDestroy:function () {
    delete this.showAnimation;
    this.hide(false);
    Ext.Sheet.superclass.beforeDestroy.call(this)
}});
Ext.reg("sheet", Ext.Sheet);
Ext.ActionSheet = Ext.extend(Ext.Sheet, {componentCls:"x-sheet-action", stretchY:true, stretchX:true, defaultType:"button", constructor:function (a) {
    a = a || {};
    Ext.ActionSheet.superclass.constructor.call(this, Ext.applyIf({floating:true}, a))
}});
Ext.reg("actionsheet", Ext.ActionSheet);
Ext.TabBar = Ext.extend(Ext.Panel, {componentCls:"x-tabbar", activeTab:null, defaultType:"tab", sortable:false, sortHoldThreshold:350, initComponent:function () {
    this.addEvents("change");
    this.layout = Ext.apply({}, this.layout || {}, {type:"hbox", align:"middle"});
    Ext.TabBar.superclass.initComponent.call(this)
}, initEvents:function () {
    if (this.sortable) {
        this.sortable = new Ext.util.Sortable(this.el, {itemSelector:".x-tab", direction:"horizontal", delay:this.sortHoldThreshold, constrain:true});
        this.mon(this.sortable, "sortchange", this.onSortChange, this)
    }
    this.mon(this.el, {touchstart:this.onTouchStart, scope:this});
    Ext.TabBar.superclass.initEvents.call(this)
}, onTouchStart:function (b, a) {
    a = b.getTarget(".x-tab");
    if (a) {
        this.onTabTap(Ext.getCmp(a.id))
    }
}, onSortChange:function (c, b, a) {
}, onTabTap:function (a) {
    if (!a.disabled) {
        if (this.cardLayout) {
            if (this.cardSwitchAnimation) {
                var b = {reverse:(this.items.indexOf(a) < this.items.indexOf(this.activeTab)) ? true : false};
                if (Ext.isObject(this.cardSwitchAnimation)) {
                    Ext.apply(b, this.cardSwitchAnimation)
                } else {
                    Ext.apply(b, {type:this.cardSwitchAnimation})
                }
            }
            this.cardLayout.setActiveItem(a.card, b || this.cardSwitchAnimation)
        }
        this.activeTab = a;
        this.fireEvent("change", this, a, a.card)
    }
}, getCardLayout:function () {
    return this.cardLayout
}});
Ext.reg("tabbar", Ext.TabBar);
Ext.Tab = Ext.extend(Ext.Button, {isTab:true, baseCls:"x-tab", pressedCls:"x-tab-pressed", activeCls:"x-tab-active", active:false, initComponent:function () {
    this.addEvents("activate", "deactivate");
    Ext.Tab.superclass.initComponent.call(this);
    var a = this.card;
    if (a) {
        this.card = null;
        this.setCard(a)
    }
}, setCard:function (a) {
    if (this.card) {
        this.mun(this.card, {activate:this.activate, deactivate:this.deactivate, scope:this})
    }
    this.card = a;
    if (a) {
        Ext.apply(this, a.tab || {});
        this.setText(this.title || a.title || this.text);
        this.setIconClass(this.iconCls || a.iconCls);
        this.setBadge(this.badgeText || a.badgeText);
        this.mon(a, {beforeactivate:this.activate, beforedeactivate:this.deactivate, scope:this})
    }
}, onRender:function () {
    Ext.Tab.superclass.onRender.apply(this, arguments);
    if (this.active) {
        this.el.addCls(this.activeCls)
    }
}, getCard:function () {
    return this.card
}, activate:function () {
    this.active = true;
    if (this.el) {
        this.el.addCls(this.activeCls)
    }
    this.fireEvent("activate", this)
}, deactivate:function () {
    this.active = false;
    if (this.el) {
        this.el.removeCls(this.activeCls)
    }
    this.fireEvent("deactivate", this)
}});
Ext.reg("tab", Ext.Tab);
Ext.TabPanel = Ext.extend(Ext.Panel, {cardSwitchAnimation:"slide", tabBarDock:"top", componentCls:"x-tabpanel", ui:"dark", initComponent:function () {
    var a = new Ext.layout.CardLayout(this.layout || {});
    this.layout = null;
    this.setLayout(a);
    this.tabBar = new Ext.TabBar(Ext.apply({}, this.tabBar || {}, {cardLayout:a, cardSwitchAnimation:this.cardSwitchAnimation, dock:this.tabBarDock, ui:this.ui, sortable:this.sortable}));
    if (this.dockedItems && !Ext.isArray(this.dockedItems)) {
        this.dockedItems = [this.dockedItems]
    } else {
        if (!this.dockedItems) {
            this.dockedItems = []
        }
    }
    this.dockedItems.push(this.tabBar);
    Ext.TabPanel.superclass.initComponent.call(this)
}, getTabBar:function () {
    return this.tabBar
}, onAdd:function (c, b) {
    var a = this.tabBar;
    c.tab = a.insert(b, {xtype:"tab", card:c});
    a.doLayout()
}, onRemove:function (b, a) {
    if (!this.destroying) {
        this.tabBar.remove(b.tab, a);
        this.tabBar.doLayout()
    }
}});
Ext.reg("tabpanel", Ext.TabPanel);
Ext.Carousel = Ext.extend(Ext.Panel, {baseCls:"x-carousel", indicator:true, ui:"dark", direction:"horizontal", horizontal:false, vertical:false, initComponent:function () {
    this.layout = {type:"card", sizeAllCards:true, hideInactive:false, itemCls:"x-carousel-item", targetCls:"x-carousel-body", setOwner:function (b) {
        Ext.layout.CardLayout.superclass.setOwner.call(this, b)
    }};
    if (this.indicator) {
        var a = Ext.isObject(this.indicator) ? this.indicator : {};
        this.indicator = new Ext.Carousel.Indicator(Ext.apply({}, a, {direction:this.direction, carousel:this, ui:this.ui}))
    }
    if (this.direction == "horizontal") {
        this.horizontal = true
    } else {
        this.vertical = true
    }
    Ext.Carousel.superclass.initComponent.call(this)
}, afterRender:function () {
    Ext.Carousel.superclass.afterRender.call(this);
    this.mon(this.body, {drag:this.onDrag, dragThreshold:5, dragend:this.onDragEnd, direction:this.direction, scope:this});
    this.el.addCls(this.baseCls + "-" + this.direction)
}, onAdd:function () {
    Ext.Carousel.superclass.onAdd.apply(this, arguments);
    var a = this.indicator;
    if (a) {
        a.onCardAdd()
    }
}, onRemove:function () {
    Ext.Carousel.superclass.onRemove.apply(this, arguments);
    var a = this.indicator;
    if (a) {
        a.onCardRemove()
    }
}, afterLayout:function () {
    Ext.Carousel.superclass.afterLayout.apply(this, arguments);
    this.currentSize = this.body.getSize();
    this.currentScroll = {x:0, y:0};
    this.updateCardPositions();
    var a = this.layout.getActiveItem();
    if (a && this.indicator) {
        this.indicator.onBeforeCardSwitch(this, a, null, this.items.indexOf(a))
    }
}, onDrag:function (b) {
    this.currentScroll = {x:b.deltaX, y:b.deltaY};
    var a = this.items.items.indexOf(this.layout.activeItem);
    if (this.horizontal) {
        if ((a == 0 && b.deltaX > 0) || (a == this.items.length - 1 && b.deltaX < 0)) {
            this.currentScroll.x = b.deltaX / 2
        }
    } else {
        if (this.vertical) {
            if ((a == 0 && b.deltaY > 0) || (a == this.items.length - 1 && b.deltaY < 0)) {
                this.currentScroll.y = b.deltaY / 2
            }
        }
    }
    this.updateCardPositions()
}, updateCardPositions:function (a) {
    var g = this.items.items, f = g.length, h, c, b, e, d;
    for (c = 0; c < f; c++) {
        b = g[c];
        if (this.isCardInRange(b)) {
            if (b.hidden) {
                b.show()
            }
            e = b.el;
            d = e.dom.style;
            if (a) {
                if (b === this.layout.activeItem) {
                    e.on("webkitTransitionEnd", this.onTransitionEnd, this, {single:true})
                }
                d.webkitTransitionDuration = "300ms"
            } else {
                d.webkitTransitionDuration = "0ms"
            }
            h = this.getCardOffset(b);
            if (this.horizontal) {
                Ext.Element.cssTransform(e, {translate:[h, 0]})
            } else {
                Ext.Element.cssTransform(e, {translate:[0, h]})
            }
        } else {
            if (!b.hidden) {
                b.hide()
            }
        }
    }
}, getCardOffset:function (c) {
    var d = this.getCardIndexOffset(c), b = this.currentSize, a = this.currentScroll;
    return this.horizontal ? (d * b.width) + a.x : (d * b.height) + a.y
}, getCardIndexOffset:function (a) {
    return this.items.items.indexOf(a) - this.getActiveIndex()
}, isCardInRange:function (a) {
    return Math.abs(this.getCardIndexOffset(a)) <= 2
}, getActiveIndex:function () {
    return this.items.indexOf(this.layout.activeItem)
}, onDragEnd:function (d, b) {
    var a, c;
    if (this.horizontal) {
        c = d.deltaX;
        a = d.previousDeltaX
    } else {
        c = d.deltaY;
        a = d.previousDeltaY
    }
    if (c < 0 && Math.abs(c) > 3 && a <= 0 && this.layout.getNext()) {
        this.next()
    } else {
        if (c > 0 && Math.abs(c) > 3 && a >= 0 && this.layout.getPrev()) {
            this.prev()
        } else {
            this.scrollToCard(this.layout.activeItem)
        }
    }
}, onBeforeCardSwitch:function (a) {
    if (!this.customDrag && this.items.indexOf(a) != -1) {
        var b = a.el.dom.style;
        b.webkitTransitionDuration = null;
        b.webkitTransform = null
    }
    return Ext.Carousel.superclass.onBeforeCardSwitch.apply(this, arguments)
}, scrollToCard:function (a) {
    this.currentScroll = {x:0, y:0};
    this.oldCard = this.layout.activeItem;
    if (a != this.oldCard && this.isCardInRange(a) && this.onBeforeCardSwitch(a, this.oldCard, this.items.indexOf(a), true) !== false) {
        this.layout.activeItem = a;
        if (this.horizontal) {
            this.currentScroll.x = -this.getCardOffset(a)
        } else {
            this.currentScroll.y = -this.getCardOffset(a)
        }
    }
    this.updateCardPositions(true)
}, onTransitionEnd:function (b, a) {
    this.customDrag = false;
    this.currentScroll = {x:0, y:0};
    if (this.oldCard && this.layout.activeItem != this.oldCard) {
        this.onCardSwitch(this.layout.activeItem, this.oldCard, this.items.indexOf(this.layout.activeItem), true)
    }
    delete this.oldCard
}, onCardSwitch:function (a, c, b, d) {
    this.currentScroll = {x:0, y:0};
    this.updateCardPositions();
    Ext.Carousel.superclass.onCardSwitch.apply(this, arguments);
    a.fireEvent("activate", a)
}, next:function () {
    var a = this.layout.getNext();
    if (a) {
        this.customDrag = true;
        this.scrollToCard(a)
    }
    return this
}, prev:function () {
    var a = this.layout.getPrev();
    if (a) {
        this.customDrag = true;
        this.scrollToCard(a)
    }
    return this
}, isVertical:function () {
    return this.vertical
}, isHorizontal:function () {
    return this.horizontal
}, beforeDestroy:function () {
    Ext.destroy(this.indicator);
    Ext.Carousel.superclass.beforeDestroy.call(this)
}});
Ext.reg("carousel", Ext.Carousel);
Ext.Carousel.Indicator = Ext.extend(Ext.Component, {baseCls:"x-carousel-indicator", initComponent:function () {
    if (this.carousel.rendered) {
        this.render(this.carousel.body);
        this.onBeforeCardSwitch(null, null, this.carousel.items.indexOf(this.carousel.layout.getActiveItem()))
    } else {
        this.carousel.on("render", function () {
            this.render(this.carousel.body)
        }, this, {single:true})
    }
    Ext.Carousel.Indicator.superclass.initComponent.call(this)
}, onRender:function () {
    Ext.Carousel.Indicator.superclass.onRender.apply(this, arguments);
    for (var a = 0, b = this.carousel.items.length; a < b; a++) {
        this.createIndicator()
    }
    this.mon(this.carousel, {beforecardswitch:this.onBeforeCardSwitch, scope:this});
    this.mon(this.el, {tap:this.onTap, scope:this});
    this.el.addCls(this.baseCls + "-" + this.direction)
}, onTap:function (g, a) {
    var b = this.el.getPageBox(), f = b.left + (b.width / 2), c = b.top + (b.height / 2), d = this.carousel;
    if ((d.isHorizontal() && g.pageX > f) || (d.isVertical() && g.pageY > c)) {
        this.carousel.next()
    } else {
        this.carousel.prev()
    }
}, createIndicator:function () {
    this.indicators = this.indicators || [];
    this.indicators.push(this.el.createChild({tag:"span"}))
}, onBeforeCardSwitch:function (d, c, a, b) {
    if (Ext.isNumber(b) && b != -1 && this.indicators[b]) {
        this.indicators[b].radioCls("x-carousel-indicator-active")
    }
}, onCardAdd:function () {
    if (this.rendered) {
        this.createIndicator()
    }
}, onCardRemove:function () {
    if (this.rendered) {
        this.indicators.pop().remove()
    }
}});
Ext.reg("carouselindicator", Ext.Carousel.Indicator);
Ext.Map = Ext.extend(Ext.Component, {baseCls:"x-map", useCurrentLocation:false, monitorResize:true, map:null, geo:null, maskMap:false, maskMapCls:"x-mask-map", initComponent:function () {
    this.mapOptions = this.mapOptions || {};
    this.scroll = false;
    if (!(window.google || {}).maps) {
        this.html = "Google Maps API is required"
    } else {
        if (this.useCurrentLocation) {
            this.geo = this.geo || new Ext.util.GeoLocation({autoLoad:false});
            this.geo.on({locationupdate:this.onGeoUpdate, locationerror:this.onGeoError, scope:this})
        }
    }
    Ext.Map.superclass.initComponent.call(this);
    this.addEvents("maprender", "centerchange", "typechange", "zoomchange");
    if (this.geo) {
        this.on({activate:this.onUpdate, scope:this, single:true});
        this.geo.updateLocation()
    }
}, onRender:function (b, a) {
    Ext.Map.superclass.onRender.apply(this, arguments);
    this.el.setVisibilityMode(Ext.Element.OFFSETS)
}, afterRender:function () {
    Ext.Map.superclass.afterRender.apply(this, arguments);
    this.renderMap()
}, onResize:function (a, b) {
    Ext.Map.superclass.onResize.apply(this, arguments);
    if (this.map) {
        google.maps.event.trigger(this.map, "resize")
    }
}, afterComponentLayout:function () {
    if (this.maskMap && !this.mask) {
        this.el.mask(null, this.maskMapCls);
        this.mask = true
    }
}, renderMap:function () {
    var b = this, c = (window.google || {}).maps;
    if (c) {
        if (Ext.is.iPad) {
            Ext.applyIf(b.mapOptions, {navigationControlOptions:{style:c.NavigationControlStyle.ZOOM_PAN}})
        }
        Ext.applyIf(b.mapOptions, {center:new c.LatLng(37.381592, -122.135672), zoom:12, mapTypeId:c.MapTypeId.ROADMAP});
        if (b.maskMap && !b.mask) {
            b.el.mask(null, this.maskMapCls);
            b.mask = true
        }
        if (b.el && b.el.dom && b.el.dom.firstChild) {
            Ext.fly(b.el.dom.firstChild).remove()
        }
        if (b.map) {
            c.event.clearInstanceListeners(b.map)
        }
        b.map = new c.Map(b.el.dom, b.mapOptions);
        var a = c.event;
        a.addListener(b.map, "zoom_changed", Ext.createDelegate(b.onZoom, b));
        a.addListener(b.map, "maptypeid_changed", Ext.createDelegate(b.onTypeChange, b));
        a.addListener(b.map, "center_changed", Ext.createDelegate(b.onCenterChange, b));
        b.fireEvent("maprender", b, b.map)
    }
}, onGeoUpdate:function (b) {
    var a;
    if (b) {
        a = this.mapOptions.center = new google.maps.LatLng(b.latitude, b.longitude)
    }
    if (this.rendered) {
        this.update(a)
    } else {
        this.on("activate", this.onUpdate, this, {single:true, data:a})
    }
}, onGeoError:function (a) {
}, onUpdate:function (c, b, a) {
    this.update((a || {}).data)
}, update:function (c) {
    var a = this, b = (window.google || {}).maps;
    if (b) {
        c = c || a.coords || new b.LatLng(37.381592, -122.135672);
        if (c && !(c instanceof b.LatLng) && "longitude" in c) {
            c = new b.LatLng(c.latitude, c.longitude)
        }
        if (!a.hidden && a.rendered) {
            a.map || a.renderMap();
            if (a.map && c instanceof b.LatLng) {
                a.map.panTo(c)
            }
        } else {
            a.on("activate", a.onUpdate, a, {single:true, data:c})
        }
    }
}, onZoom:function () {
    this.mapOptions.zoom = (this.map && this.map.getZoom ? this.map.getZoom() : this.mapOptions.zoom) || 10;
    this.fireEvent("zoomchange", this, this.map, this.mapOptions.zoom)
}, onTypeChange:function () {
    this.mapOptions.mapTypeId = this.map && this.map.getMapTypeId ? this.map.getMapTypeId() : this.mapOptions.mapTypeId;
    this.fireEvent("typechange", this, this.map, this.mapOptions.mapTypeId)
}, onCenterChange:function () {
    this.mapOptions.center = this.map && this.map.getCenter ? this.map.getCenter() : this.mapOptions.center;
    this.fireEvent("centerchange", this, this.map, this.mapOptions.center)
}, getState:function () {
    return this.mapOptions
}, onDestroy:function () {
    Ext.destroy(this.geo);
    if (this.maskMap && this.mask) {
        this.el.unmask()
    }
    if (this.map && (window.google || {}).maps) {
        google.maps.event.clearInstanceListeners(this.map)
    }
    Ext.Map.superclass.onDestroy.call(this)
}});
Ext.reg("map", Ext.Map);
Ext.NestedList = Ext.extend(Ext.Panel, {componentCls:"x-nested-list", layout:"card", cardSwitchAnimation:"slide", backButton:null, backText:"Back", useTitleAsBackText:true, updateTitleText:true, displayField:"text", loadingText:"Loading...", emptyText:"No items available.", onItemDisclosure:false, clearSelectionDelay:200, allowDeselect:false, getItemTextTpl:function (a) {
    return"{" + this.displayField + "}"
}, getTitleTextTpl:function (a) {
    return"{" + this.displayField + "}"
}, renderTitleText:function (b) {
    if (!b.titleTpl) {
        b.titleTpl = new Ext.XTemplate(this.getTitleTextTpl(b))
    }
    var a = b.getRecord();
    if (a) {
        return b.titleTpl.applyTemplate(a.data)
    } else {
        if (b.isRoot) {
            return this.title || this.backText
        } else {
            throw new Error("No RecordNode passed into renderTitleText")
        }
    }
}, useToolbar:true, getDetailCard:function (b, a) {
    return false
}, initComponent:function () {
    var b = Ext.StoreMgr.lookup(this.store), a = b.getRootNode(), c = a.getRecord() ? this.renderTitleText(a) : this.title || "";
    this.store = b;
    if (this.useToolbar) {
        this.backButton = new Ext.Button({text:this.backText, ui:"back", handler:this.onBackTap, scope:this, hidden:true});
        if (!this.toolbar || !this.toolbar.isComponent) {
            this.toolbar = Ext.apply({}, this.toolbar || {}, {dock:"top", xtype:"toolbar", ui:"light", title:c, items:[]});
            this.toolbar.items.unshift(this.backButton);
            this.toolbar = new Ext.Toolbar(this.toolbar);
            this.dockedItems = this.dockedItems || [];
            this.dockedItems.push(this.toolbar)
        } else {
            this.toolbar.insert(0, this.backButton)
        }
    }
    this.items = [this.getSubList(a)];
    Ext.NestedList.superclass.initComponent.call(this);
    this.on("itemtap", this.onItemTap, this);
    this.addEvents("listchange", "leafitemtap")
}, getListConfig:function (b) {
    var c = b.internalId, a = this.emptyText;
    return{itemId:c, xtype:"list", autoDestroy:true, recordNode:b, store:this.store.getSubStore(b), loadingText:this.loadingText, onItemDisclosure:this.onItemDisclosure, displayField:this.displayField, singleSelect:true, clearSelectionOnDeactivate:false, bubbleEvents:["itemtap", "containertap", "beforeselect", "itemdoubletap", "selectionchange"], itemTpl:'<span<tpl if="leaf == true"> class="x-list-item-leaf"</tpl>>' + this.getItemTextTpl(b) + "</span>", deferEmptyText:true, allowDeselect:this.allowDeselect, refresh:function () {
        if (this.hasSkippedEmptyText) {
            this.emptyText = a
        }
        Ext.List.prototype.refresh.apply(this, arguments)
    }}
}, getSubList:function (b) {
    var a = this.items, c, d = b.internalId;
    if (a && a.get) {
        c = a.get(d)
    }
    if (c) {
        return c
    } else {
        return this.getListConfig(b)
    }
}, addNextCard:function (b, e) {
    var c, a = b ? b.parentNode : null, d;
    if (b.leaf) {
        d = this.getDetailCard(b, a);
        if (d) {
            c = this.add(d)
        }
    } else {
        c = this.getSubList(b);
        c = this.add(c)
    }
    return c
}, setActivePath:function (o) {
    var n = o.substr(0, 1) === "/", h = 0, e = this.store, p = e.tree, f, g, c, m, b;
    if (n) {
        o = o.substr(1)
    }
    m = Ext.toArray(o.split("/"));
    b = m.length;
    if (n) {
        var l = this.items, a = this.items.items, k = l.length;
        for (; k > 1; k--) {
            this.remove(a[k - 1], true)
        }
        var d = a[0].recordNode;
        if (d.id !== m[0]) {
            throw new Error("rootNode doesn't match!")
        }
        h = 1
    }
    for (; h < b; h++) {
        if (m[h] !== "") {
            f = p.getNodeById(m[h]);
            g = this.addNextCard(f);
            if (g) {
                c = g
            }
        }
    }
    if (!c) {
        throw new Error("Card was not found when trying to add to NestedList.")
    }
    this.setActiveItem(c, false);
    this.fireEvent("listchange", this, c);
    this.syncToolbar()
}, syncToolbar:function (e) {
    var g = e || this.getActiveItem(), h = this.items.indexOf(g), b = g.recordNode, a = b ? b.parentNode : null, d = this.backButton, c = this.useTitleAsBackText && a ? this.renderTitleText(a) : this.backText, f = (h !== 0) ? "show" : "hide";
    if (d) {
        d[f]();
        if (a) {
            d.setText(c)
        }
    }
    if (this.toolbar && this.updateTitleText) {
        this.toolbar.setTitle(b && b.getRecord() ? this.renderTitleText(b) : this.title || "");
        this.toolbar.doLayout()
    }
}, onItemTap:function (l, d, a, i) {
    var k = l.getStore(), f = k.getAt(d), m = f.node, g = m ? m.parentNode : null, h = this.displayField, c, b, j;
    j = this.addNextCard(m);
    if (m.leaf) {
        this.fireEvent("leafitemtap", l, d, a, i, j)
    }
    if (j) {
        b = this.items.indexOf(j);
        this.setActiveItem(j, {type:this.cardSwitchAnimation});
        this.syncToolbar(j)
    }
}, onBackTap:function () {
    var g = this.getActiveItem(), h = this.items.indexOf(g);
    if (h != 0) {
        var a = h - 1, c = this.items.getAt(a), j = c.recordNode, d = j.getRecord(), e = j ? j.parentNode : null, f = this.backButton, b = (a !== 0) ? "show" : "hide", i;
        this.on("cardswitch", function (k, m) {
            var l = c.getSelectionModel();
            this.remove(g);
            if (this.clearSelectionDelay) {
                Ext.defer(l.deselectAll, this.clearSelectionDelay, l)
            }
        }, this, {single:true});
        this.setActiveItem(c, {type:this.cardSwitchAnimation, reverse:true, scope:this});
        this.syncToolbar(c)
    }
}});
Ext.reg("nestedlist", Ext.NestedList);
Ext.Picker = Ext.extend(Ext.Sheet, {componentCls:"x-picker", stretchX:true, stretchY:true, hideOnMaskTap:false, doneButton:"完成", cancelButton:"取消", height:220, useTitles:false, defaultType:"pickerslot", initComponent:function () {
    this.addEvents("pick", "change", "cancel");
    this.layout = {type:"hbox", align:"stretch"};
    if (this.slots) {
        this.items = this.items ? (Ext.isArray(this.items) ? this.items : [this.items]) : [];
        this.items = this.items.concat(this.slots)
    }
    if (this.useTitles) {
        this.defaults = Ext.applyIf(this.defaults || {}, {title:""})
    }
    this.on("slotpick", this.onSlotPick, this);
    if (this.doneButton || this.cancelButton) {
        var a = [];
        if (this.cancelButton) {
            a.push(Ext.apply({handler:this.onCancelButtonTap, scope:this}, ((Ext.isObject(this.cancelButton) ? this.cancelButton : {text:String(this.cancelButton)}))))
        }
        a.push({xtype:"spacer"});
        if (this.doneButton) {
            a.push(Ext.apply({ui:"action", handler:this.onDoneButtonTap, scope:this}, ((Ext.isObject(this.doneButton) ? this.doneButton : {text:String(this.doneButton)}))))
        }
        this.toolbar = new Ext.Toolbar(Ext.applyIf(this.buttonBar || {dock:"top", items:a, defaults:{xtype:"button"}}));
        this.dockedItems = this.dockedItems ? (Ext.isArray(this.dockedItems) ? this.dockedItems : [this.dockedItems]) : [];
        this.dockedItems.push(this.toolbar)
    }
    Ext.Picker.superclass.initComponent.call(this)
}, afterRender:function () {
    Ext.Picker.superclass.afterRender.apply(this, arguments);
    if (this.value) {
        this.setValue(this.value, false)
    }
}, onDoneButtonTap:function () {
    var a = this.animSheet("exit");
    Ext.apply(a, {after:function () {
        this.fireEvent("change", this, this.getValue())
    }, scope:this});
    this.hide(a)
}, onCancelButtonTap:function () {
    var a = this.animSheet("exit");
    Ext.apply(a, {after:function () {
        this.setValue(this.values);
        this.fireEvent("cancel", this)
    }, scope:this});
    this.hide(a)
}, onSlotPick:function (c, b, a) {
    this.fireEvent("pick", this, this.getValue(), c);
    return false
}, setValue:function (b, e) {
    var f, a = this.items.items, d = a.length;
    if (!b) {
        for (var c = 0; c < d; c++) {
            a[c].setSelectedNode(0)
        }
        return this
    }
    Ext.iterate(b, function (g, h) {
        f = this.child("[name=" + g + "]");
        if (f) {
            f.setValue(h, e)
        }
    }, this);
    this.values = b;
    return this
}, getValue:function () {
    var b = {}, a = this.items.items, e = a.length, d, c;
    for (c = 0; c < e; c++) {
        d = a[c];
        b[d.name] = d.getValue()
    }
    return b
}});
Ext.regModel("x-textvalue", {fields:["text", "value"]});
Ext.Picker.Slot = Ext.extend(Ext.DataView, {isSlot:true, flex:1, name:null, displayField:"text", valueField:"value", align:"center", itemSelector:"div.x-picker-item", componentCls:"x-picker-slot", renderTpl:['<div class="x-picker-mask">', '<div class="x-picker-bar"></div>', "</div>"], selectedIndex:0, getElConfig:function () {
    return{tag:"div", id:this.id, cls:"x-picker-" + this.align}
}, initComponent:function () {
    if (!this.name) {
        throw new Error("Each picker slot is required to have a name.")
    }
    Ext.apply(this.renderSelectors, {mask:".x-picker-mask", bar:".x-picker-bar"});
    this.scroll = {direction:"vertical", useIndicators:false, friction:0.7, acceleration:25, snapDuration:200, animationDuration:200};
    this.tpl = new Ext.XTemplate(['<tpl for=".">', '<div class="x-picker-item {cls} <tpl if="extra">x-picker-invalid</tpl>">{' + this.displayField + "}</div>", "</tpl>"]);
    var d = this.data, f = [], c = d && d.length, a, b, e;
    if (d && Ext.isArray(d) && c) {
        for (a = 0; a < c; a++) {
            b = d[a];
            e = {};
            if (Ext.isArray(b)) {
                e[this.valueField] = b[0];
                e[this.displayField] = b[1]
            } else {
                if (Ext.isString(b)) {
                    e[this.valueField] = b;
                    e[this.displayField] = b
                } else {
                    if (Ext.isObject(b)) {
                        e = b
                    }
                }
            }
            f.push(e)
        }
        this.store = new Ext.data.Store({model:"x-textvalue", data:f});
        this.tempStore = true
    } else {
        if (this.store) {
            this.store = Ext.StoreMgr.lookup(this.store)
        }
    }
    this.enableBubble("slotpick");
    if (this.title) {
        this.title = new Ext.Component({dock:"top", componentCls:"x-picker-slot-title", html:this.title});
        this.dockedItems = this.title
    }
    Ext.Picker.Slot.superclass.initComponent.call(this);
    if (this.value !== undefined) {
        this.setValue(this.value, false)
    }
}, setupBar:function () {
    this.el.setStyle({padding:""});
    var a = this.bar.getY() - this.el.getY();
    this.barHeight = this.bar.getHeight();
    this.el.setStyle({padding:a + "px 0"});
    this.slotPadding = a;
    this.scroller.updateBoundary();
    this.scroller.setSnap(this.barHeight);
    this.setSelectedNode(this.selectedIndex, false)
}, afterComponentLayout:function () {
    Ext.defer(this.setupBar, 200, this)
}, initEvents:function () {
    this.mon(this.scroller, {scrollend:this.onScrollEnd, scope:this})
}, onScrollEnd:function (a, b) {
    this.selectedNode = this.getNode(Math.round(b.y / this.barHeight));
    this.selectedIndex = this.indexOf(this.selectedNode);
    this.fireEvent("slotpick", this, this.getValue(), this.selectedNode)
}, scrollToNode:function (c, a) {
    var b = Ext.fly(c).getOffsetsTo(this.scrollEl)[1];
    this.scroller.scrollTo({y:b}, a !== false ? true : false)
}, onItemTap:function (a) {
    Ext.Picker.Slot.superclass.onItemTap.apply(this, arguments);
    this.setSelectedNode(a);
    this.selectedNode = a;
    this.selectedIndex = this.indexOf(a);
    this.fireEvent("slotpick", this, this.getValue(), this.selectedNode)
}, getSelectedNode:function () {
    return this.selectedNode
}, setSelectedNode:function (b, a) {
    if (Ext.isNumber(b)) {
        b = this.getNode(b)
    } else {
        if (b.isModel) {
            b = this.getNode(this.store.indexOf(b))
        }
    }
    if (b) {
        this.selectedNode = b;
        this.selectedIndex = this.indexOf(b);
        this.scrollToNode(b, a)
    }
}, getValue:function () {
    var a = this.store.getAt(this.selectedIndex);
    return a ? a.get(this.valueField) : null
}, setValue:function (c, a) {
    var b = this.store.find(this.valueField, c);
    if (b != -1) {
        if (!this.rendered) {
            this.selectedIndex = b;
            return
        }
        this.setSelectedNode(b, a)
    }
}, onDestroy:function () {
    if (this.tempStore) {
        this.store.destroyStore();
        this.store = null
    }
    Ext.Picker.Slot.superclass.onDestroy.call(this)
}});
Ext.reg("pickerslot", Ext.Picker.Slot);
Ext.DatePicker = Ext.extend(Ext.Picker, {yearFrom:1980, yearTo:new Date().getFullYear(), monthText:"Month", dayText:"Day", yearText:"Year", slotOrder:["month", "day", "year"], initComponent:function () {
    var j = this.yearFrom, e = this.yearTo, f = [], h = [], b = [], g, c, d, a;
    if (j > e) {
        c = j;
        j = e;
        e = c
    }
    for (d = j; d <= e; d++) {
        f.push({text:d, value:d})
    }
    a = this.getDaysInMonth(1, new Date().getFullYear());
    for (d = 0; d < a; d++) {
        h.push({text:d + 1, value:d + 1})
    }
    for (d = 0, g = Date.monthNames.length; d < g; d++) {
        b.push({text:Date.monthNames[d], value:d + 1})
    }
    this.slots = [];
    this.slotOrder.forEach(function (i) {
        this.slots.push(this.createSlot(i, h, b, f))
    }, this);
    Ext.DatePicker.superclass.initComponent.call(this)
}, afterRender:function () {
    Ext.DatePicker.superclass.afterRender.apply(this, arguments);
    this.setValue(this.value)
}, createSlot:function (b, d, a, c) {
    switch (b) {
        case"year":
            return{name:"year", align:"center", data:c, title:this.useTitles ? this.yearText : false, flex:3};
        case"month":
            return{name:b, align:"right", data:a, title:this.useTitles ? this.monthText : false, flex:4};
        case"day":
            return{name:"day", align:"center", data:d, title:this.useTitles ? this.dayText : false, flex:2}
    }
}, onSlotPick:function (f, e) {
    var c = f.name, b, a, d;
    if (c === "month" || c === "year") {
        d = this.child("[name=day]");
        b = this.getValue();
        a = this.getDaysInMonth(b.getMonth() + 1, b.getFullYear());
        d.store.clearFilter();
        d.store.filter({fn:function (g) {
            return g.get("extra") === true || g.get("value") <= a
        }});
        d.scroller.updateBoundary(true)
    }
    Ext.DatePicker.superclass.onSlotPick.apply(this, arguments)
}, getValue:function () {
    var c = Ext.DatePicker.superclass.getValue.call(this), b = this.getDaysInMonth(c.month, c.year), a = Math.min(c.day, b);
    return new Date(c.year, c.month - 1, a)
}, setValue:function (b, a) {
    if (!Ext.isDate(b) && !Ext.isObject(b)) {
        b = null
    }
    if (Ext.isDate(b)) {
        this.value = {day:b.getDate(), year:b.getFullYear(), month:b.getMonth() + 1}
    } else {
        this.value = b
    }
    return Ext.DatePicker.superclass.setValue.call(this, this.value, a)
}, getDaysInMonth:function (c, b) {
    var a = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    return c == 2 && this.isLeapYear(b) ? 29 : a[c - 1]
}, isLeapYear:function (a) {
    return !!((a & 3) === 0 && (a % 100 || (a % 400 === 0 && a)))
}});
Ext.reg("datepicker", Ext.DatePicker);
Ext.Media = Ext.extend(Ext.Component, {url:"", enableControls:true, autoResume:false, autoPause:true, preload:true, playing:false, afterRender:function () {
    var a = this.getConfiguration();
    Ext.apply(a, {src:this.url, preload:this.preload ? "auto" : "none"});
    if (this.enableControls) {
        a.controls = "controls"
    }
    if (this.loop) {
        a.loop = "loop"
    }
    this.media = this.el.createChild(a);
    Ext.Media.superclass.afterRender.call(this);
    this.on({scope:this, activate:this.onActivate, beforedeactivate:this.onDeactivate})
}, onActivate:function () {
    if (this.autoResume && !this.playing) {
        this.play()
    }
}, onDeactivate:function () {
    if (this.autoPause && this.playing) {
        this.pause()
    }
}, play:function () {
    this.media.dom.play();
    this.playing = true
}, pause:function () {
    this.media.dom.pause();
    this.playing = false
}, toggle:function () {
    if (this.playing) {
        this.pause()
    } else {
        this.play()
    }
}});
Ext.reg("media", Ext.Media);
Ext.Video = Ext.extend(Ext.Media, {posterUrl:"", componentCls:"x-video", afterRender:function () {
    Ext.Video.superclass.afterRender.call(this);
    if (this.posterUrl) {
        this.media.hide();
        this.ghost = this.el.createChild({cls:"x-video-ghost", style:"width: 100%; height: 100%; background: #000 url(" + this.posterUrl + ") center center no-repeat; -webkit-background-size: 100% auto;"});
        this.ghost.on("tap", this.onGhostTap, this, {single:true})
    }
}, onGhostTap:function () {
    this.media.show();
    this.ghost.hide();
    this.play()
}, getConfiguration:function () {
    return{tag:"video", width:"100%", height:"100%"}
}});
Ext.reg("video", Ext.Video);
Ext.Audio = Ext.extend(Ext.Media, {componentCls:"x-audio", onActivate:function () {
    Ext.Audio.superclass.onActivate.call(this);
    if (Ext.is.Phone) {
        this.media.show()
    }
}, onDeactivate:function () {
    Ext.Audio.superclass.onDeactivate.call(this);
    if (Ext.is.Phone) {
        this.media.hide()
    }
}, getConfiguration:function () {
    var a = !this.enableControls;
    if (!Ext.supports.AudioTag) {
        return{tag:"embed", type:"audio/mpeg", target:"myself", controls:"true", hidden:a}
    } else {
        return{tag:"audio", hidden:a}
    }
}});
Ext.reg("audio", Ext.Audio);
Ext.MessageBox = Ext.extend(Ext.Sheet, {centered:true, renderHidden:true, ui:"dark", componentCls:"x-msgbox", enterAnimation:"pop", exitAnimation:"pop", autoHeight:true, defaultTextHeight:75, constructor:function (a) {
    a = a || {};
    var c = a.ui || this.ui || "", b = a.componentCls || this.componentCls;
    delete a.html;
    this.titleBar = Ext.create({xtype:"toolbar", ui:c, dock:"top", cls:b + "-title", title:"&#160;"});
    this.buttonBar = Ext.create({xtype:"toolbar", ui:c, dock:"bottom", layout:{pack:"center"}, cls:b + "-buttons"});
    a = Ext.apply({ui:c, dockedItems:[this.titleBar, this.buttonBar], renderSelectors:{body:"." + b + "-body", iconEl:"." + b + "-icon", msgContentEl:"." + b + "-content", msgEl:"." + b + "-text", inputsEl:"." + b + "-inputs", inputEl:"." + b + "-input-single", multiLineEl:"." + b + "-input-textarea"}}, a || {});
    Ext.MessageBox.superclass.constructor.call(this, a)
}, renderTpl:['<div class="{componentCls}-body"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>', '<div class="{componentCls}-icon x-hidden-display"></div>', '<div class="{componentCls}-content">', '<div class="{componentCls}-text"></div>', '<div class="{componentCls}-inputs x-hidden-display">', '<input type="text" class="{componentCls}-input {componentCls}-input-single" />', '<textarea class="{componentCls}-input {componentCls}-input-textarea"></textarea>', "</div>", "</div>", "</div>"], onClick:function (b) {
    if (b) {
        var a = b.config || {};
        if (typeof a.fn == "function") {
            a.fn.call(a.scope || null, b.itemId || b.text, a.input ? a.input.dom.value : null, a)
        }
        if (a.cls) {
            this.el.removeCls(a.cls)
        }
        if (a.input) {
            a.input.dom.blur()
        }
    }
    this.hide()
}, show:function (c) {
    var e, d, g = {autocomplete:"off", autocapitalize:"off", autocorrect:"off", maxlength:0, autofocus:true, placeholder:"", type:"text"}, a = /true|on/i;
    this.rendered || this.render(document.body);
    c = Ext.applyIf(c || {}, {multiLine:false, prompt:false, value:"", modal:true});
    if (c.title) {
        this.titleBar.setTitle(c.title);
        this.titleBar.show()
    } else {
        this.titleBar.hide()
    }
    if (this.inputsEl && (c.multiLine || c.prompt)) {
        this.inputsEl.show();
        if (this.multiLineEl && c.multiLine) {
            this.inputEl && this.inputEl.hide();
            this.multiLineEl.show().setHeight(Ext.isNumber(c.multiLine) ? parseFloat(c.multiLine) : this.defaultTextHeight);
            c.input = this.multiLineEl
        } else {
            if (this.inputEl) {
                this.inputEl.show();
                this.multiLineEl && this.multiLineEl.hide();
                c.input = this.inputEl
            }
        }
        if (Ext.isObject(c.prompt)) {
            Ext.apply(g, c.prompt)
        }
        for (d in g) {
            if (g.hasOwnProperty(d)) {
                e = g[d];
                c.input.dom.setAttribute(d.toLowerCase(), /^auto/i.test(d) ? (a.test(e + "") ? "on" : "off") : e)
            }
        }
    } else {
        this.inputsEl && this.inputsEl.hide()
    }
    this.setIcon(c.icon || "", false);
    this.updateText(c.msg, false);
    if (c.cls) {
        this.el.addCls(c.cls)
    }
    this.modal = !!c.modal;
    var f = this.buttonBar, b = [];
    f.removeAll();
    Ext.each([].concat(c.buttons || Ext.MessageBox.OK), function (h) {
        if (h) {
            b.push(Ext.applyIf({config:c, scope:this, handler:this.onClick}, h))
        }
    }, this);
    f.add(b);
    if (f.rendered) {
        f.doLayout()
    }
    Ext.MessageBox.superclass.show.call(this, c.animate);
    if (c.input) {
        c.input.dom.value = c.value || "";
        if (a.test(g.autofocus + "") && !("autofocus" in c.input.dom)) {
            c.input.dom.focus()
        }
    }
    return this
}, onOrientationChange:function () {
    this.doComponentLayout();
    Ext.MessageBox.superclass.onOrientationChange.apply(this, arguments)
}, adjustScale:function () {
    Ext.apply(this, {maxWidth:window.innerWidth, maxHeight:window.innerHeight, minWidth:window.innerWidth * 0.5, minHeight:window.innerHeight * 0.5})
}, doComponentLayout:function () {
    this.adjustScale();
    return Ext.MessageBox.superclass.doComponentLayout.apply(this, arguments)
}, alert:function (d, c, b, a) {
    return this.show({title:d, msg:c, buttons:Ext.MessageBox.OK, fn:b, scope:a, icon:Ext.MessageBox.INFO})
}, confirm:function (d, c, b, a) {
    return this.show({title:d, msg:c, buttons:Ext.MessageBox.YESNO, fn:function (e) {
        b.call(a, e)
    }, scope:a, icon:Ext.MessageBox.QUESTION})
}, prompt:function (g, f, c, b, e, d, a) {
    return this.show({title:g, msg:f, buttons:Ext.MessageBox.OKCANCEL, fn:function (i, h) {
        c.call(b, i, h)
    }, scope:b, icon:Ext.MessageBox.QUESTION, prompt:a || true, multiLine:e, value:d})
}, updateText:function (b, a) {
    if (this.msgEl) {
        this.msgEl.update(b ? String(b) : "&#160;");
        if (a !== false) {
            this.doComponentLayout()
        }
    }
    return this
}, setIcon:function (a, b) {
    if (a) {
        this.iconEl.show();
        this.iconEl.replaceCls(this.iconCls, a)
    } else {
        this.iconEl.replaceCls(this.iconCls, "x-hidden-display")
    }
    if (b !== false) {
        this.doComponentLayout()
    }
    this.iconCls = a;
    return this
}});
(function () {
    var a = Ext.MessageBox;
    Ext.apply(a, {OK:{text:"确定", itemId:"ok", ui:"action"}, CANCEL:{text:"取消", itemId:"cancel"}, YES:{text:"确定", itemId:"yes", ui:"action"}, NO:{text:"取消", itemId:"no"}, INFO:"x-msgbox-info", WARNING:"x-msgbox-warning", QUESTION:"x-msgbox-question", ERROR:"x-msgbox-error"});
    Ext.apply(a, {OKCANCEL:[a.CANCEL, a.OK], YESNOCANCEL:[a.CANCEL, a.NO, a.YES], YESNO:[a.NO, a.YES]})
})();
Ext.reg("messagebox", Ext.MessageBox);
Ext.reg("msgbox", Ext.MessageBox);
Ext.Msg = new Ext.MessageBox();
Ext.form.FormPanel = Ext.extend(Ext.Panel, {standardSubmit:false, componentCls:"x-form", url:undefined, baseParams:undefined, waitTpl:new Ext.XTemplate('<div class="{cls}">{message}&hellip;</div>'), submitOnAction:true, getElConfig:function () {
    return Ext.apply(Ext.form.FormPanel.superclass.getElConfig.call(this), {tag:"form"})
}, initComponent:function () {
    this.addEvents("submit", "beforesubmit", "exception");
    Ext.form.FormPanel.superclass.initComponent.call(this);
    this.on("action", this.onFieldAction, this)
}, afterRender:function () {
    Ext.form.FormPanel.superclass.afterRender.call(this);
    this.el.on("submit", this.onSubmit, this)
}, onSubmit:function (b, a) {
    if (!this.standardSubmit || this.fireEvent("beforesubmit", this, this.getValues(true)) === false) {
        if (b) {
            b.stopEvent()
        }
    }
}, onFieldAction:function (a) {
    if (this.submitOnAction) {
        a.blur();
        this.submit()
    }
}, submit:function (a) {
    var b = this.el.dom || {}, c;
    a = Ext.apply({url:this.url || b.action, submitDisabled:false, method:b.method || "post", autoAbort:false, params:null, waitMsg:null, headers:null, success:null, failure:null}, a || {});
    c = this.getValues(this.standardSubmit || !a.submitDisabled);
    if (this.standardSubmit) {
        if (b) {
            if (a.url && Ext.isEmpty(b.action)) {
                b.action = a.url
            }
            b.method = (a.method || b.method).toLowerCase();
            if (this.fireEvent("beforesubmit", this, c, a) !== false) {
                b.submit()
            }
        }
        return null
    }
    if (this.fireEvent("beforesubmit", this, c, a) !== false) {
        if (a.waitMsg) {
            this.showMask(a.waitMsg)
        }
        return Ext.Ajax.request({url:a.url, method:a.method, rawData:Ext.urlEncode(Ext.apply(Ext.apply({}, this.baseParams || {}), a.params || {}, c)), autoAbort:a.autoAbort, headers:Ext.apply({"Content-Type":"application/x-www-form-urlencoded; charset=UTF-8"}, a.headers || {}), scope:this, callback:function (d, g, e) {
            var f = e.responseText;
            this.hideMask();
            if (g) {
                e = Ext.decode(f);
                g = !!e.success;
                if (g) {
                    if (Ext.isFunction(a.success)) {
                        a.success.call(a.scope || this, this, e, f)
                    }
                    this.fireEvent("submit", this, e);
                    return
                }
            }
            if (Ext.isFunction(a.failure)) {
                a.failure.call(a.scope || this, this, e, f)
            }
            this.fireEvent("exception", this, e)
        }})
    }
}, loadRecord:function (a) {
    if (a && a.data) {
        this.setValues(a.data);
        this.record = a
    }
    return this
}, loadModel:function () {
    return this.loadRecord.apply(this, arguments)
}, getRecord:function () {
    return this.record
}, updateRecord:function (b, e) {
    var a, c, d;
    if (b && (a = b.fields)) {
        c = this.getValues(e);
        for (d in c) {
            if (c.hasOwnProperty(d) && a.containsKey(d)) {
                b.set(d, c[d])
            }
        }
    }
    return this
}, setValues:function (b) {
    var a = this.getFields(), c, e, d;
    b = b || {};
    for (c in b) {
        if (b.hasOwnProperty(c)) {
            e = a[c];
            d = b[c];
            if (e) {
                if (Ext.isArray(e)) {
                    e.forEach(function (f) {
                        if (Ext.isArray(b[c])) {
                            f.setChecked((d.indexOf(f.getValue()) != -1))
                        } else {
                            f.setChecked((d == f.getValue()))
                        }
                    })
                } else {
                    if (e.setChecked) {
                        e.setChecked(d)
                    } else {
                        e.setValue(d)
                    }
                }
            }
        }
    }
    return this
}, getValues:function (d) {
    var a = this.getFields(), e, b = {}, c;
    for (c in a) {
        if (a.hasOwnProperty(c)) {
            if (Ext.isArray(a[c])) {
                b[c] = [];
                a[c].forEach(function (f) {
                    if (f.isChecked() && !(d && f.disabled)) {
                        if (f instanceof Ext.form.Radio) {
                            b[c] = f.getValue()
                        } else {
                            b[c].push(f.getValue())
                        }
                    }
                })
            } else {
                e = a[c];
                if (!(d && e.disabled)) {
                    if (e instanceof Ext.form.Checkbox) {
                        b[c] = (e.isChecked()) ? e.getValue() : null
                    } else {
                        b[c] = e.getValue()
                    }
                }
            }
        }
    }
    return b
}, reset:function () {
    this.getFieldsAsArray().forEach(function (a) {
        a.reset()
    });
    return this
}, enable:function () {
    this.getFieldsAsArray().forEach(function (a) {
        a.enable()
    });
    return this
}, disable:function () {
    this.getFieldsAsArray().forEach(function (a) {
        a.disable()
    });
    return this
}, getFieldsAsArray:function () {
    var a = [];
    var b = function (c) {
        if (c.isField) {
            a.push(c)
        }
        if (c.isContainer) {
            c.items.each(b)
        }
    };
    this.items.each(b);
    return a
}, getFields:function (b) {
    var a = {}, d;
    var c = function (e) {
        if (e.isField) {
            d = e.getName();
            if ((b && d == b) || typeof b == "undefined") {
                if (a.hasOwnProperty(d)) {
                    if (!Ext.isArray(a[d])) {
                        a[d] = [a[d]]
                    }
                    a[d].push(e)
                } else {
                    a[d] = e
                }
            }
        }
        if (e.isContainer) {
            e.items.each(c)
        }
    };
    this.items.each(c);
    return(b) ? (a[b] || []) : a
}, getFieldsFromItem:function () {
}, showMask:function (a, b) {
    a = Ext.isString(a) ? {message:a} : a;
    if (a && this.waitTpl) {
        this.maskTarget = b = Ext.get(b || a.target) || this.el;
        b && b.mask(this.waitTpl.apply(a))
    }
    return this
}, hideMask:function () {
    if (this.maskTarget) {
        this.maskTarget.unmask();
        delete this.maskTarget
    }
    return this
}});
Ext.form.FormPanel.prototype.load = Ext.form.FormPanel.prototype.loadModel;
Ext.reg("formpanel", Ext.form.FormPanel);
Ext.reg("form", Ext.form.FormPanel);
Ext.form.FieldSet = Ext.extend(Ext.Panel, {componentCls:"x-form-fieldset", initComponent:function () {
    this.componentLayout = this.getLayout();
    Ext.form.FieldSet.superclass.initComponent.call(this)
}, afterLayout:function (a) {
    Ext.form.FieldSet.superclass.afterLayout.call(this, a);
    if (this.title && !this.titleEl) {
        this.setTitle(this.title)
    } else {
        if (this.titleEl) {
            this.el.insertFirst(this.titleEl)
        }
    }
    if (this.instructions && !this.instructionsEl) {
        this.setInstructions(this.instructions)
    } else {
        if (this.instructionsEl) {
            this.el.appendChild(this.instructionsEl)
        }
    }
}, setTitle:function (a) {
    if (this.rendered) {
        if (!this.titleEl) {
            this.titleEl = this.el.insertFirst({cls:this.componentCls + "-title"})
        }
        this.titleEl.setHTML(a)
    } else {
        this.title = a
    }
    return this
}, setInstructions:function (a) {
    if (this.rendered) {
        if (!this.instructionsEl) {
            this.instructionsEl = this.el.createChild({cls:this.componentCls + "-instructions"})
        }
        this.instructionsEl.setHTML(a)
    } else {
        this.instructions = a
    }
    return this
}});
Ext.reg("fieldset", Ext.form.FieldSet);
Ext.form.Field = Ext.extend(Ext.Component, {isField:true, fieldCls:"x-form-field", baseCls:"x-field", inputCls:undefined, disabled:false, renderTpl:['<tpl if="label">', '<div class="x-form-label"><span>{label}</span></div>', "</tpl>", '<tpl if="fieldEl">', '<div class="x-form-field-container"><input id="{inputId}" type="{inputType}" name="{name}" class="{fieldCls}"', '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>', '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>', '<tpl if="style">style="{style}" </tpl>', '<tpl if="maxlength">maxlength="{maxlength}" </tpl>', '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>', '<tpl if="autoCapitalize">autocapitalize="{autoCapitalize}" </tpl>', '<tpl if="autoCorrect">autocorrect="{autoCorrect}" </tpl> />', '<tpl if="useMask"><div class="x-field-mask"></div></tpl>', "</div>", '<tpl if="useClearIcon"><div class="x-field-clear-container"><div class="x-field-clear x-hidden-visibility">&#215;</div></div></tpl>', "</tpl>"], isFormField:true, autoCreateField:true, inputType:"text", label:null, labelWidth:"30%", labelAlign:"left", required:false, useMask:false, initComponent:function () {
    Ext.form.Field.superclass.initComponent.call(this)
}, getName:function () {
    return this.name || this.id || ""
}, applyRenderSelectors:function () {
    this.renderSelectors = Ext.applyIf(this.renderSelectors || {}, {mask:".x-field-mask", labelEl:".x-form-label", fieldEl:"." + Ext.util.Format.trim(this.renderData.fieldCls).replace(/ /g, ".")});
    Ext.form.Field.superclass.applyRenderSelectors.call(this)
}, initRenderData:function () {
    Ext.form.Field.superclass.initRenderData.apply(this, arguments);
    Ext.applyIf(this.renderData, {disabled:this.disabled, fieldCls:"x-input-" + this.inputType + (this.inputCls ? " " + this.inputCls : ""), fieldEl:!this.fieldEl && this.autoCreateField, inputId:Ext.id(), label:this.label, labelAlign:"x-label-align-" + this.labelAlign, name:this.getName(), required:this.required, style:this.style, tabIndex:this.tabIndex, inputType:this.inputType, useMask:this.useMask});
    return this.renderData
}, initEvents:function () {
    Ext.form.Field.superclass.initEvents.apply(this, arguments);
    if (this.fieldEl) {
        if (this.useMask && this.mask) {
            this.mon(this.mask, {click:this.onMaskTap, scope:this})
        }
    }
}, onRender:function () {
    Ext.form.Field.superclass.onRender.apply(this, arguments);
    var a = [];
    if (this.required) {
        a.push("x-field-required")
    }
    if (this.label) {
        a.push("x-label-align-" + this.labelAlign)
    }
    this.el.addCls(a)
}, afterRender:function () {
    Ext.form.Field.superclass.afterRender.apply(this, arguments);
    if (this.label) {
        this.setLabelWidth(this.labelWidth)
    }
    this.initValue()
}, isDisabled:function () {
    return this.disabled
}, onEnable:function () {
    this.fieldEl.dom.disabled = false
}, onDisable:function () {
    this.fieldEl.dom.disabled = true
}, initValue:function () {
    this.setValue(this.value || "", true);
    this.originalValue = this.getValue()
}, isDirty:function () {
    if (this.disabled || !this.rendered) {
        return false
    }
    return String(this.getValue()) !== String(this.originalValue)
}, onMaskTap:function (a) {
    if (this.disabled) {
        return false
    }
    return true
}, showMask:function (a) {
    if (this.mask) {
        this.mask.setStyle("display", "block")
    }
}, hideMask:function (a) {
    if (this.mask) {
        this.mask.setStyle("display", "none")
    }
}, reset:function () {
    this.setValue(this.originalValue)
}, getValue:function () {
    if (!this.rendered || !this.fieldEl) {
        return this.value
    }
    return this.fieldEl.getValue()
}, setValue:function (a) {
    this.value = a;
    if (this.rendered && this.fieldEl) {
        this.fieldEl.dom.value = (Ext.isEmpty(a) ? "" : a)
    }
    return this
}, setLabelWidth:function (a) {
    if (this.labelEl) {
        this.labelEl.setWidth(a)
    }
    return this
}});
Ext.reg("field", Ext.form.Field);
Ext.form.Slider = Ext.extend(Ext.form.Field, {ui:"slider", inputCls:"x-slider", inputType:"slider", minValue:0, maxValue:100, animationDuration:200, value:0, trackWidth:null, monitorOrientation:true, renderTpl:['<tpl if="label">', '<div class="x-form-label"><span>{label}</span></div>', "</tpl>", '<tpl if="fieldEl">', '<div id="{inputId}" name="{name}" class="{fieldCls}"', '<tpl if="tabIndex">tabIndex="{tabIndex}"</tpl>', '<tpl if="style">style="{style}" </tpl>', "/></tpl>"], increment:1, constructor:function (a) {
    this.addEvents("beforechange", "change", "drag", "dragend");
    Ext.form.Slider.superclass.constructor.call(this, a)
}, initComponent:function () {
    this.tabIndex = -1;
    if (this.increment == 0) {
        this.increment = 1
    }
    this.increment = Math.abs(this.increment);
    this.values = [this.value];
    Ext.form.Slider.superclass.initComponent.apply(this, arguments);
    if (this.thumbs == undefined) {
        var a = [], b = this.values, d = b.length, c, e = this.getThumbClass();
        for (c = 0; c < d; c++) {
            a[a.length] = new e({value:b[c], slider:this, listeners:{scope:this, drag:this.onDrag, dragend:this.onThumbDragEnd}})
        }
        this.thumbs = a
    }
}, initValue:function () {
    var a = this.getThumb();
    if (a.dragObj) {
        a.dragObj.updateBoundary()
    }
    Ext.form.Slider.superclass.initValue.apply(this, arguments)
}, onOrientationChange:function () {
    Ext.form.Slider.superclass.onOrientationChange.apply(this, arguments);
    var b = this, a = this.getThumb();
    if (a.dragObj) {
        setTimeout(function () {
            a.dragObj.updateBoundary();
            b.moveThumb(a, b.getPixelValue(a.getValue(), a), 0)
        }, 100)
    }
}, getThumbClass:function () {
    return Ext.form.Slider.Thumb
}, setValue:function (e, d, c) {
    if (typeof c == "undefined") {
        c = true
    }
    c = !!c;
    var a = this.getThumb(), b = a.getValue(), f = this.constrain(e);
    if (this.fireEvent("beforechange", this, a, f, b) !== false) {
        if (c) {
            this.moveThumb(a, this.getPixelValue(f, a), d)
        }
        a.setValue(f);
        this.doComponentLayout();
        this.fireEvent("change", this, a, f, b)
    }
    return this
}, constrain:function (b) {
    var a = b % this.increment;
    b -= a;
    if (Math.abs(a) >= (this.increment / 2)) {
        b += (a > 0) ? this.increment : -this.increment
    }
    b = Math.max(this.minValue, b);
    b = Math.min(this.maxValue, b);
    return b
}, getValue:function () {
    return this.getThumb().getValue()
}, getThumb:function () {
    return this.thumbs[0]
}, getSliderValue:function (b, d) {
    var a = d.dragObj.offsetBoundary.right, c = this.maxValue - this.minValue, e;
    this.trackWidth = (a > 0) ? a : this.trackWidth;
    e = c / this.trackWidth;
    return this.minValue + (e * (b))
}, getPixelValue:function (e, c) {
    var a = c.dragObj.offsetBoundary.right, b = this.maxValue - this.minValue, d;
    this.trackWidth = (a > 0) ? a : this.trackWidth;
    d = this.trackWidth / b;
    return(d * (e - this.minValue))
}, renderThumbs:function () {
    var a = this.thumbs, c = a.length, b;
    for (b = 0; b < c; b++) {
        a[b].render(this.fieldEl)
    }
}, onThumbDragEnd:function (a) {
    var b = this.getThumbValue(a);
    this.setValue(b);
    this.fireEvent("dragend", this, a.thumb, this.constrain(b))
}, getThumbValue:function (a) {
    var b = a.thumb;
    return this.getSliderValue(-a.getOffset().x, b)
}, onDrag:function (a) {
    var b = this.getThumbValue(a);
    this.fireEvent("drag", this, a.thumb, this.constrain(b))
}, onTap:function (f) {
    if (!this.disabled) {
        var c = this.fieldEl.getPageBox(), d = f.pageX - c.left, b = this.getNearest(d), a = b.dragObj.size.width / 2;
        this.setValue(this.getSliderValue(d - a, b), this.animationDuration, true)
    }
}, moveThumb:function (a, b, c) {
    a.dragObj.setOffset(new Ext.util.Offset(b, 0), c)
}, afterRender:function (a) {
    var b = this;
    b.renderThumbs();
    Ext.form.Slider.superclass.afterRender.apply(b, arguments);
    b.fieldEl.on({scope:b, tap:b.onTap})
}, getNearest:function (a) {
    return this.thumbs[0]
}, setThumbsDisabled:function (b) {
    var a = this.thumbs, d = a.length, c = 0;
    for (; c < d; c++) {
        a[c].dragObj[b ? "disable" : "enable"]()
    }
}, disable:function () {
    Ext.form.Slider.superclass.disable.call(this);
    this.setThumbsDisabled(true)
}, enable:function () {
    Ext.form.Slider.superclass.enable.call(this);
    this.setThumbsDisabled(false)
}});
Ext.reg("sliderfield", Ext.form.Slider);
Ext.form.Slider.Thumb = Ext.extend(Ext.form.Field, {isField:false, baseCls:"x-thumb", autoCreateField:false, draggable:true, value:0, onRender:function () {
    this.draggable = {direction:"horizontal", constrain:this.slider.fieldEl, revert:false, thumb:this};
    Ext.form.Slider.Thumb.superclass.onRender.apply(this, arguments)
}, setValue:function (a) {
    this.value = a;
    return this
}, getValue:function () {
    return this.value
}});
Ext.reg("sliderthumb", Ext.form.Slider.Thumb);
Ext.form.Toggle = Ext.extend(Ext.form.Slider, {minValue:0, maxValue:1, ui:"toggle", inputType:"toggle", minValueCls:"x-toggle-off", maxValueCls:"x-toggle-on", animationDuration:70, toggle:function () {
    var a = this.thumbs[0], b = a.getValue();
    this.setValue(b == this.minValue ? this.maxValue : this.minValue, this.animationDuration)
}, setValue:function (a) {
    Ext.form.Toggle.superclass.setValue.call(this, a, this.animationDuration);
    var b = this.fieldEl;
    if (this.constrain(a) === this.minValue) {
        b.addCls(this.minValueCls);
        b.removeCls(this.maxValueCls)
    } else {
        b.addCls(this.maxValueCls);
        b.removeCls(this.minValueCls)
    }
}, onTap:function () {
    if (!this.disabled) {
        this.toggle()
    }
}, getThumbClass:function () {
    return Ext.form.Toggle.Thumb
}});
Ext.reg("togglefield", Ext.form.Toggle);
Ext.form.Toggle.Thumb = Ext.extend(Ext.form.Slider.Thumb, {onRender:function () {
    Ext.form.Toggle.Thumb.superclass.onRender.apply(this, arguments);
    Ext.DomHelper.append(this.el, [
        {cls:"x-toggle-thumb-off", html:"<span>OFF</span>"},
        {cls:"x-toggle-thumb-on", html:"<span>ON</span>"},
        {cls:"x-toggle-thumb-thumb"}
    ])
}});
Ext.form.Text = Ext.extend(Ext.form.Field, {ui:"text", focusCls:"x-field-focus", maxLength:0, placeHolder:undefined, autoComplete:undefined, autoCapitalize:undefined, autoCorrect:undefined, isFocused:false, isClearIconVisible:false, useMask:Ext.is.iOS, initComponent:function () {
    this.addEvents("focus", "blur", "keyup", "change", "action");
    this.enableBubble("action");
    Ext.form.Text.superclass.initComponent.apply(this, arguments)
}, applyRenderSelectors:function () {
    this.renderSelectors = Ext.applyIf(this.renderSelectors || {}, {clearIconEl:".x-field-clear", clearIconContainerEl:".x-field-clear-container"});
    Ext.form.Text.superclass.applyRenderSelectors.call(this)
}, initRenderData:function () {
    var e = Ext.form.Text.superclass.initRenderData.call(this), d = this.autoComplete, c = this.autoCapitalize, b = this.autoCorrect;
    Ext.applyIf(e, {placeHolder:this.placeHolder, maxlength:this.maxLength, useClearIcon:this.useClearIcon});
    var a = [true, "on"];
    if (d !== undefined) {
        e.autoComplete = (a.indexOf(d) !== -1) ? "on" : "off"
    }
    if (c !== undefined) {
        e.autoCapitalize = (a.indexOf(c) !== -1) ? "on" : "off"
    }
    if (b !== undefined) {
        e.autoCorrect = (a.indexOf(b) !== -1) ? "on" : "off"
    }
    this.renderData = e;
    return e
}, initEvents:function () {
    Ext.form.Text.superclass.initEvents.call(this);
    if (this.fieldEl) {
        this.mon(this.fieldEl, {focus:this.onFocus, blur:this.onBlur, keyup:this.onKeyUp, paste:this.updateClearIconVisibility, mousedown:this.onBeforeFocus, scope:this});
        if (this.clearIconEl) {
            this.mon(this.clearIconContainerEl, {scope:this, tap:this.onClearIconTap})
        }
    }
}, onEnable:function () {
    Ext.form.Text.superclass.onEnable.apply(this, arguments);
    this.disabled = false;
    this.updateClearIconVisibility()
}, onDisable:function () {
    Ext.form.Text.superclass.onDisable.apply(this, arguments);
    this.blur();
    this.hideClearIcon()
}, onClearIconTap:function () {
    if (!this.disabled) {
        this.setValue("")
    }
}, updateClearIconVisibility:function () {
    var a = this.getValue();
    if (!a) {
        a = ""
    }
    if (a.length < 1) {
        this.hideClearIcon()
    } else {
        this.showClearIcon()
    }
    return this
}, showClearIcon:function () {
    if (!this.disabled && this.fieldEl && this.clearIconEl && !this.isClearIconVisible) {
        this.isClearIconVisible = true;
        this.fieldEl.addCls("x-field-clearable");
        this.clearIconEl.removeCls("x-hidden-visibility")
    }
    return this
}, hideClearIcon:function () {
    if (this.fieldEl && this.clearIconEl && this.isClearIconVisible) {
        this.isClearIconVisible = false;
        this.fieldEl.removeCls("x-field-clearable");
        this.clearIconEl.addCls("x-hidden-visibility")
    }
    return this
}, afterRender:function () {
    Ext.form.Text.superclass.afterRender.call(this);
    this.updateClearIconVisibility()
}, onBeforeFocus:function (a) {
    this.fireEvent("beforefocus", a)
}, beforeFocus:Ext.emptyFn, onMaskTap:function (a) {
    if (Ext.form.Text.superclass.onMaskTap.apply(this, arguments) !== true) {
        return false
    }
    this.maskCorrectionTimer = Ext.defer(this.showMask, 1000, this);
    this.hideMask()
}, onFocus:function (a) {
    if (this.mask) {
        if (this.maskCorrectionTimer) {
            clearTimeout(this.maskCorrectionTimer)
        }
        this.hideMask()
    }
    this.beforeFocus();
    if (this.focusCls) {
        this.el.addCls(this.focusCls)
    }
    if (!this.isFocused) {
        this.isFocused = true;
        this.startValue = this.getValue();
        this.fireEvent("focus", this, a)
    }
    Ext.currentlyFocusedField = this
}, beforeBlur:Ext.emptyFn, onBlur:function (b) {
    this.beforeBlur();
    if (this.focusCls) {
        this.el.removeCls(this.focusCls)
    }
    this.isFocused = false;
    var a = this.getValue();
    if (String(a) != String(this.startValue)) {
        this.fireEvent("change", this, a, this.startValue)
    }
    this.fireEvent("blur", this, b);
    this.updateClearIconVisibility();
    this.showMask();
    this.afterBlur();
    Ext.currentlyFocusedField = null
}, afterBlur:Ext.emptyFn, focus:function () {
    if (this.rendered && this.fieldEl && this.fieldEl.dom.focus) {
        this.fieldEl.dom.focus()
    }
    return this
}, blur:function () {
    if (this.rendered && this.fieldEl && this.fieldEl.dom.blur) {
        this.fieldEl.dom.blur()
    }
    return this
}, setValue:function () {
    Ext.form.Text.superclass.setValue.apply(this, arguments);
    this.updateClearIconVisibility()
}, onKeyUp:function (a) {
    this.updateClearIconVisibility();
    this.fireEvent("keyup", this, a);
    if (a.browserEvent.keyCode === 13) {
        this.blur();
        this.fireEvent("action", this, a)
    }
}});
Ext.reg("textfield", Ext.form.Text);
Ext.form.TextField = Ext.extend(Ext.form.Text, {constructor:function () {
    console.warn("Ext.form.TextField has been deprecated and will be removed in Sencha Touch 1.0. Please use Ext.form.Text instead");
    Ext.form.TextField.superclass.constructor.apply(this, arguments)
}});
Ext.form.Password = Ext.extend(Ext.form.Text, {inputType:"password", autoCapitalize:false});
Ext.reg("passwordfield", Ext.form.Password);
Ext.form.Email = Ext.extend(Ext.form.Text, {inputType:"email", autoCapitalize:false});
Ext.reg("emailfield", Ext.form.Email);
Ext.form.Url = Ext.extend(Ext.form.Text, {inputType:"url", autoCapitalize:false});
Ext.reg("urlfield", Ext.form.Url);
Ext.form.Search = Ext.extend(Ext.form.Text, {inputType:"search"});
Ext.reg("searchfield", Ext.form.Search);
Ext.form.Number = Ext.extend(Ext.form.Text, {ui:"number", inputType:"number", minValue:undefined, maxValue:undefined, stepValue:undefined, renderTpl:['<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>', '<tpl if="fieldEl"><div class="x-form-field-container">', '<input id="{inputId}" type="{inputType}" name="{name}" class="{fieldCls}"', '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>', '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>', '<tpl if="style">style="{style}" </tpl>', '<tpl if="minValue != undefined">min="{minValue}" </tpl>', '<tpl if="maxValue != undefined">max="{maxValue}" </tpl>', '<tpl if="stepValue != undefined">step="{stepValue}" </tpl>', '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>', '<tpl if="autoCapitalize">autocapitalize="{autoCapitalize}" </tpl>', '<tpl if="autoFocus">autofocus="{autoFocus}" </tpl>', "/>", '<tpl if="useMask"><div class="x-field-mask"></div></tpl>', "</div></tpl>", '<tpl if="useClearIcon"><div class="x-field-clear-container"><div class="x-field-clear x-hidden-visibility">&#215;</div><div></tpl>'], onRender:function () {
    Ext.apply(this.renderData, {maxValue:this.maxValue, minValue:this.minValue, stepValue:this.stepValue});
    Ext.form.Number.superclass.onRender.apply(this, arguments)
}});
Ext.reg("numberfield", Ext.form.Number);
Ext.form.Spinner = Ext.extend(Ext.form.Number, {componentCls:"x-spinner", minValue:Number.NEGATIVE_INFINITY, maxValue:Number.MAX_VALUE, incrementValue:1, accelerateOnTapHold:true, defaultValue:0, cycle:false, disableInput:false, useClearIcon:false, autoCapitalize:false, renderTpl:['<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>', '<tpl if="fieldEl">', '<div class="{componentCls}-body">', '<div class="{componentCls}-down"><span>-</span></div>', '<div class="x-form-field-container">', '<input id="{inputId}" type="{type}" name="{name}" class="{fieldCls}"', '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>', '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>', '<tpl if="style">style="{style}" </tpl>', '<tpl if="minValue != undefined">min="{minValue}" </tpl>', '<tpl if="maxValue != undefined">max="{maxValue}" </tpl>', '<tpl if="stepValue != undefined">step="{stepValue}" </tpl>', '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>', '<tpl if="autoFocus">autofocus="{autoFocus}" </tpl>', "/>", '<tpl if="useMask"><div class="x-field-mask"></div></tpl>', "</div>", '<div class="{componentCls}-up"><span>+</span></div>', "</div>", "</tpl>"], initComponent:function () {
    this.addEvents("spin", "spindown", "spinup");
    Ext.form.Spinner.superclass.initComponent.call(this)
}, onRender:function () {
    this.renderData.disableInput = this.disableInput;
    Ext.applyIf(this.renderSelectors, {spinUpEl:".x-spinner-up", spinDownEl:".x-spinner-down"});
    Ext.form.Spinner.superclass.onRender.apply(this, arguments);
    this.downRepeater = this.createRepeater(this.spinDownEl, this.onSpinDown);
    this.upRepeater = this.createRepeater(this.spinUpEl, this.onSpinUp)
}, initValue:function () {
    if (isNaN(this.defaultValue)) {
        this.defaultValue = 0
    }
    if (!this.value) {
        this.value = this.defaultValue
    }
    Ext.form.Spinner.superclass.initValue.apply(this, arguments)
}, createRepeater:function (b, a) {
    var c = new Ext.util.TapRepeater(b, {accelerate:this.accelerateOnTapHold});
    this.mon(c, {tap:a, touchstart:this.onTouchStart, touchend:this.onTouchEnd, preventDefault:true, scope:this});
    return c
}, onSpinDown:function () {
    if (!this.disabled) {
        this.spin(true)
    }
}, onSpinUp:function () {
    if (!this.disabled) {
        this.spin(false)
    }
}, onKeyUp:function (a) {
    Ext.form.Spinner.superclass.onKeyUp.apply(this, arguments)
}, onTouchStart:function (a) {
    if (!this.disabled) {
        a.el.addCls("x-button-pressed")
    }
}, onTouchEnd:function (a) {
    a.el.removeCls("x-button-pressed")
}, setValue:function (a) {
    a = parseFloat(a);
    if (isNaN(a)) {
        a = this.defaultValue
    }
    Ext.form.Spinner.superclass.setValue.call(this, a)
}, spin:function (g) {
    var e = parseFloat(this.getValue()), b = this.incrementValue, d = this.cycle, c = this.minValue, a = this.maxValue, f = g ? "down" : "up";
    if (g) {
        e -= b
    } else {
        e += b
    }
    e = (isNaN(e)) ? this.defaultValue : e;
    if (e < c) {
        e = d ? a : c
    } else {
        if (e > a) {
            e = d ? c : a
        }
    }
    this.setValue(e);
    this.fireEvent("spin" + f, this, e);
    this.fireEvent("spin", this, e, f)
}, destroy:function () {
    Ext.destroy(this.downRepeater, this.upRepeater);
    Ext.form.Spinner.superclass.destroy.call(this, arguments)
}});
Ext.reg("spinnerfield", Ext.form.Spinner);
Ext.form.Hidden = Ext.extend(Ext.form.Field, {ui:"hidden", inputType:"hidden", tabIndex:-1});
Ext.reg("hiddenfield", Ext.form.Hidden);
Ext.form.HiddenField = Ext.extend(Ext.form.Hidden, {constructor:function () {
    console.warn("Ext.form.HiddenField has been deprecated and will be removed in Sencha Touch 1.0. Please use Ext.form.Hidden instead");
    Ext.form.HiddenField.superclass.constructor.apply(this, arguments)
}});
Ext.form.Checkbox = Ext.extend(Ext.form.Field, {ui:"checkbox", inputType:"checkbox", checked:false, value:"", constructor:function (a) {
    this.addEvents("check", "uncheck");
    Ext.form.Checkbox.superclass.constructor.call(this, a)
}, renderTpl:['<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>', '<tpl if="fieldEl"><input id="{inputId}" type="{inputType}" name="{name}" class="{fieldCls}" tabIndex="-1" ', '<tpl if="checked"> checked </tpl>', '<tpl if="style">style="{style}" </tpl> value="{inputValue}" />', "</tpl>"], onRender:function () {
    var a = this.getBooleanIsChecked(this.checked);
    Ext.apply(this.renderData, {inputValue:String(this.value), checked:a});
    Ext.form.Checkbox.superclass.onRender.apply(this, arguments);
    if (this.fieldEl) {
        this.mon(this.fieldEl, {click:this.onChange, scope:this});
        this.setChecked(a);
        this.originalState = this.isChecked()
    }
}, onChange:function (a) {
    if (a) {
        if (a.browserEvent) {
            a = a.browserEvent
        }
        if (Ext.supports.Touch && !a.isSimulated) {
            a.preventDefault();
            a.stopPropagation();
            return
        }
    }
    if (this.isChecked()) {
        this.fireEvent("check", this)
    } else {
        this.fireEvent("uncheck", this)
    }
}, isChecked:function () {
    if (this.rendered) {
        return this.fieldEl.dom.checked || false
    } else {
        return !!this.checked
    }
}, setChecked:function (b) {
    var d = this.getBooleanIsChecked(b), e = this.rendered, a, c;
    if (e) {
        c = this.fieldEl.dom;
        a = c.checked
    } else {
        a = !!this.checked
    }
    if (a != d) {
        if (e) {
            c.checked = d
        } else {
            this.checked = d
        }
        this.onChange()
    }
    return this
}, check:function () {
    return this.setChecked(true)
}, uncheck:function () {
    return this.setChecked(false)
}, reset:function () {
    Ext.form.Checkbox.superclass.reset.apply(this, arguments);
    this.setChecked(this.originalState);
    return this
}, getBooleanIsChecked:function (a) {
    return/^(true|1|on)/i.test(String(a))
}, getSameGroupFields:function () {
    var b = this.el.up("form"), c = Ext.getCmp(b.id), a = [];
    if (c) {
        a = c.getFields(this.getName())
    }
    return a
}, getGroupValues:function () {
    var a = [];
    this.getSameGroupFields().forEach(function (b) {
        if (b.isChecked()) {
            a.push(b.getValue())
        }
    });
    return a
}, setGroupValues:function (a) {
    this.getSameGroupFields().forEach(function (b) {
        b.setChecked((a.indexOf(b.getValue()) !== -1))
    });
    return this
}, setValue:function (a) {
    a = String(a);
    Ext.form.Checkbox.superclass.setValue.call(this, a)
}});
Ext.reg("checkboxfield", Ext.form.Checkbox);
Ext.form.Radio = Ext.extend(Ext.form.Checkbox, {inputType:"radio", ui:"radio", getGroupValue:function () {
    var c, a = this.getSameGroupFields();
    for (var b = 0; b < a.length; b++) {
        c = a[b];
        if (c.isChecked()) {
            return c.getValue()
        }
    }
    return null
}, setGroupValue:function (d) {
    var e, b = this.getSameGroupFields(), c = 0, a = b.length;
    for (; c < a; c++) {
        e = b[c];
        if (e.getValue() == d) {
            e.check();
            return
        }
    }
}});
Ext.reg("radiofield", Ext.form.Radio);
Ext.form.Select = Ext.extend(Ext.form.Text, {ui:"select", valueField:"value", displayField:"text", tabIndex:-1, useMask:true, monitorOrientation:true, initComponent:function () {
    var a = this.options;
    if (this.store) {
        this.store = Ext.StoreMgr.lookup(this.store)
    } else {
        this.store = new Ext.data.Store({fields:[this.valueField, this.displayField]});
        if (a && Ext.isArray(a) && a.length > 0) {
            this.setOptions(this.options)
        }
    }
    Ext.form.Select.superclass.initComponent.call(this);
    this.addEvents("change")
}, onRender:function () {
    Ext.form.Select.superclass.onRender.apply(this, arguments);
    var a = this.hiddenName;
    if (a) {
        this.hiddenField = this.el.insertSibling({name:a, tag:"input", type:"hidden"}, "after")
    }
}, getPicker:function () {
    if (!this.picker) {
        this.picker = new Ext.Picker({slots:[
            {align:"center", name:this.name, valueField:this.valueField, displayField:this.displayField, value:this.getValue(), store:this.store}
        ], listeners:{change:this.onPickerChange, scope:this}})
    }
    return this.picker
}, getListPanel:function () {
    if (!this.listPanel) {
        this.listPanel = new Ext.Panel({floating:true, stopMaskTapEvent:false, hideOnMaskTap:true, cls:"x-select-overlay", scroll:"vertical", items:{xtype:"list", store:this.store, itemId:"list", scroll:false, itemTpl:['<span class="x-list-label">{' + this.displayField + "}</span>", '<span class="x-list-selected"></span>'], listeners:{select:this.onListSelect, scope:this}}})
    }
    return this.listPanel
}, onOrientationChange:function () {
    if (this.listPanel && !this.listPanel.hidden && !Ext.is.Phone) {
        this.listPanel.showBy(this.el, false, false)
    }
}, onMaskTap:function () {
    if (this.disabled) {
        return
    }
    this.showComponent()
}, showComponent:function () {
    if (Ext.is.Phone) {
        var c = this.getPicker(), b = this.name, e = {};
        e[b] = this.getValue();
        c.show();
        c.setValue(e)
    } else {
        var d = this.getListPanel(), a = this.store.findExact(this.valueField, this.value);
        d.showBy(this.el, "fade", false);
        d.down("#list").getSelectionModel().select(a != -1 ? a : 0, false, true)
    }
}, onListSelect:function (a, b) {
    if (b) {
        this.setValue(b.get(this.valueField));
        this.fireEvent("change", this, this.getValue())
    }
    this.listPanel.hide({type:"fade", out:true, scope:this})
}, onPickerChange:function (a, c) {
    var b = this.getValue(), d = c[this.name];
    if (d != b) {
        this.setValue(d);
        this.fireEvent("change", this, d)
    }
}, setValue:function (d) {
    var b = 0, a = this.hiddenField, c;
    if (d) {
        b = this.store.findExact(this.valueField, d)
    }
    c = this.store.getAt(b);
    if (c && this.rendered) {
        this.fieldEl.dom.value = c.get(this.displayField);
        this.value = c.get(this.valueField);
        if (a) {
            a.dom.value = this.value
        }
    } else {
        if (this.rendered) {
            this.fieldEl.dom.value = d
        }
        this.value = d
    }
    if (this.picker) {
        var e = {};
        e[this.name] = this.value;
        this.picker.setValue(e)
    }
    return this
}, getValue:function () {
    return this.value
}, setOptions:function (b, a) {
    if (!b) {
        this.store.clearData();
        this.setValue(null)
    } else {
        this.store.loadData(b, a)
    }
}, destroy:function () {
    Ext.form.Select.superclass.destroy.apply(this, arguments);
    Ext.destroy(this.listPanel, this.picker, this.hiddenField)
}});
Ext.reg("selectfield", Ext.form.Select);
Ext.form.TextArea = Ext.extend(Ext.form.Text, {ui:"textarea", maxRows:undefined, autoCapitalize:false, renderTpl:['<tpl if="label"><div class="x-form-label"><span>{label}</span></div></tpl>', '<tpl if="fieldEl"><div class="x-form-field-container">', '<textarea id="{inputId}" type="{type}" name="{name}" class="{fieldCls}"', '<tpl if="tabIndex">tabIndex="{tabIndex}" </tpl>', '<tpl if="placeHolder">placeholder="{placeHolder}" </tpl>', '<tpl if="style">style="{style}" </tpl>', '<tpl if="maxRows != undefined">rows="{maxRows}" </tpl>', '<tpl if="maxlength">maxlength="{maxlength}" </tpl>', '<tpl if="autoComplete">autocomplete="{autoComplete}" </tpl>', '<tpl if="autoCapitalize">autocapitalize="{autoCapitalize}" </tpl>', '<tpl if="autoFocus">autofocus="{autoFocus}" </tpl>', "></textarea>", '<tpl if="useMask"><div class="x-field-mask"></div></tpl>', "</div></tpl>"], onRender:function () {
    this.renderData.maxRows = this.maxRows;
    Ext.form.TextArea.superclass.onRender.apply(this, arguments)
}, onKeyUp:function (a) {
    this.fireEvent("keyup", this, a)
}});
Ext.reg("textareafield", Ext.form.TextArea);
Ext.form.DatePicker = Ext.extend(Ext.form.Field, {ui:"select", picker:null, destroyPickerOnHide:false, initComponent:function () {
    this.addEvents("change");
    this.tabIndex = -1;
    this.useMask = true;
    Ext.form.Text.superclass.initComponent.apply(this, arguments)
}, getDatePicker:function () {
    if (!this.datePicker) {
        if (this.picker instanceof Ext.DatePicker) {
            this.datePicker = this.picker
        } else {
            this.datePicker = new Ext.DatePicker(Ext.apply(this.picker || {}))
        }
        this.datePicker.setValue(this.value || null);
        this.datePicker.on({scope:this, change:this.onPickerChange, hide:this.onPickerHide})
    }
    return this.datePicker
}, onMaskTap:function () {
    if (Ext.form.DatePicker.superclass.onMaskTap.apply(this, arguments) !== true) {
        return false
    }
    this.getDatePicker().show()
}, onPickerChange:function (a, b) {
    this.setValue(b);
    this.fireEvent("change", this, this.getValue())
}, onPickerHide:function () {
    if (this.destroyPickerOnHide && this.datePicker) {
        this.datePicker.destroy()
    }
}, setValue:function (b, a) {
    if (this.datePicker) {
        this.datePicker.setValue(b, a);
        this.value = (b != null) ? this.datePicker.getValue() : null
    } else {
        if (!Ext.isDate(b) && !Ext.isObject(b)) {
            b = null
        }
        if (Ext.isObject(b)) {
            this.value = new Date(b.year, b.month - 1, b.day)
        } else {
            this.value = b
        }
    }
    if (this.rendered) {
        this.fieldEl.dom.value = this.getValue(true)
    }
    return this
}, getValue:function (b) {
    var a = this.value || null;
    return(b && Ext.isDate(a)) ? a.format(Ext.util.Format.defaultDateFormat) : a
}, onDestroy:function () {
    if (this.datePicker) {
        this.datePicker.destroy()
    }
    Ext.form.DatePicker.superclass.onDestroy.call(this)
}});
Ext.reg("datepickerfield", Ext.form.DatePicker);
Ext.layout.LayoutManager = new Ext.AbstractManager({create:function (a, b) {
    if (!a) {
        a = b
    }
    if (Ext.isString(a)) {
        return new this.types[a || b]
    } else {
        if (Ext.isObject(a)) {
            if (a.isLayout) {
                return a
            } else {
                return new this.types[a.type || b](a)
            }
        }
    }
}});
Ext.regLayout = function () {
    return Ext.layout.LayoutManager.registerType.apply(Ext.layout.LayoutManager, arguments)
};
Ext.layout.Layout = Ext.extend(Object, {isLayout:true, initialized:false, constructor:function (a) {
    this.id = Ext.id(null, "ext-layout-" + this.type + "-");
    Ext.apply(this, a)
}, layout:function () {
    var a = this;
    a.layoutBusy = true;
    a.initLayout();
    if (a.beforeLayout.apply(a, arguments) !== false) {
        a.onLayout.apply(a, arguments);
        a.afterLayout();
        a.owner.needsLayout = false;
        a.layoutBusy = false
    }
}, beforeLayout:function () {
    this.renderItems(this.getLayoutItems(), this.getTarget());
    return true
}, renderItems:function (a, e) {
    var d = a.length, b = 0, c;
    for (; b < d; b++) {
        c = a[b];
        if (c && !c.rendered) {
            this.renderItem(c, b, e)
        } else {
            if (!this.isValidParent(c, e)) {
                this.moveItem(c, b, e)
            }
        }
    }
}, renderItem:function (b, a, c) {
    if (!b.rendered) {
        b.render(c, a);
        this.configureItem(b, a);
        this.childrenChanged = true
    }
}, moveItem:function (b, a, c) {
    if (typeof a == "number") {
        a = c.dom.childNodes[a]
    }
    c = c.dom || c;
    c.insertBefore(b.el.dom, a || null);
    b.container = c;
    this.configureItem(b, a);
    this.childrenChanged = true
}, initLayout:function () {
    if (!this.initialized && !Ext.isEmpty(this.targetCls)) {
        this.getTarget().addCls(this.targetCls)
    }
    this.initialized = true
}, setOwner:function (a) {
    this.owner = a
}, getLayoutItems:function () {
    return[]
}, isValidParent:function (a, b) {
    var c = a.el ? a.el.dom : Ext.getDom(a);
    return b && (c.parentNode == (b.dom || b))
}, configureItem:function (b, a) {
    if (this.itemCls) {
        b.el.addCls(this.itemCls)
    }
}, onLayout:Ext.emptyFn, afterLayout:Ext.emptyFn, onRemove:Ext.emptyFn, onDestroy:Ext.emptyFn, afterRemove:function (a) {
    if (this.itemCls && a.rendered) {
        a.el.removeCls(this.itemCls)
    }
}, destroy:function () {
    if (!Ext.isEmpty(this.targetCls)) {
        var a = this.getTarget();
        if (a) {
            a.removeCls(this.targetCls)
        }
    }
    this.onDestroy()
}});
Ext.layout.ComponentLayout = Ext.extend(Ext.layout.Layout, {type:"component", monitorChildren:true, beforeLayout:function (d, c) {
    Ext.layout.ComponentLayout.superclass.beforeLayout.call(this);
    var b = this.owner, a = b.isVisible(), e;
    if (!a && b.hiddenOwnerCt) {
        e = b.hiddenOwnerCt.layoutOnShow;
        e.remove(b);
        e.add(b);
        b.needsLayout = {width:d, height:c, isSetSize:false}
    }
    return a && this.needsLayout(d, c)
}, needsLayout:function (c, a) {
    this.lastComponentSize = this.lastComponentSize || {width:-Infinity, height:-Infinity};
    var b = this.childrenChanged;
    this.childrenChanged = false;
    return(b || this.lastComponentSize.width !== c || this.lastComponentSize.height !== a)
}, setElementSize:function (c, b, a) {
    if (b !== undefined && a !== undefined) {
        c.setSize(b, a)
    } else {
        if (a !== undefined) {
            c.setHeight(a)
        } else {
            if (b !== undefined) {
                c.setWidth(b)
            }
        }
    }
}, getTarget:function () {
    return this.owner.el
}, setTargetSize:function (b, a) {
    this.setElementSize(this.owner.el, b, a);
    this.lastComponentSize = {width:b, height:a}
}, afterLayout:function () {
    var b = this.owner, e = b.layout, d = b.ownerCt, h, g, f, c, a;
    b.afterComponentLayout(this);
    if (e && e.isLayout) {
        e.layout()
    }
    if (d && d.componentLayout && d.componentLayout.monitorChildren && !d.componentLayout.layoutBusy) {
        d.componentLayout.childrenChanged = true;
        if (d.layout && !d.layout.layoutBusy) {
            if (d.layout.type == "autocontainer") {
                d.doComponentLayout(c, a)
            } else {
                d.layout.layout()
            }
        }
    }
}});
Ext.layout.AutoComponentLayout = Ext.extend(Ext.layout.ComponentLayout, {type:"autocomponent", onLayout:function (b, a) {
    this.setTargetSize(b, a)
}});
Ext.regLayout("autocomponent", Ext.layout.AutoComponentLayout);
Ext.layout.DockLayout = Ext.extend(Ext.layout.ComponentLayout, {type:"dock", itemCls:"x-docked", onLayout:function (a, p) {
    var m = this, b = m.owner, j = b.body, d = b.ownerCt, i = b.layout, f = b.collapsed, e = b.contracted, k = b.expanded, h = m.headerItem, l = m.getTarget(), n = false, o = false, g;
    var c = m.info = {boxes:[], size:{width:a, height:p}, padding:{top:l.getPadding("t"), right:l.getPadding("r"), bottom:l.getPadding("b"), left:l.getPadding("l")}, border:{top:l.getBorderWidth("t"), right:l.getBorderWidth("r"), bottom:l.getBorderWidth("b"), left:l.getBorderWidth("l")}, bodyMargin:{top:j.getMargin("t"), right:j.getMargin("r"), bottom:j.getMargin("b"), left:j.getMargin("l")}, bodyBox:{}};
    if (p === undefined || p === null || a === undefined || a === null || e) {
        if ((p === undefined || p === null) && (a === undefined || a === null)) {
            o = true;
            n = true;
            if (!b.animCollapse || (!k && !e)) {
                m.setTargetSize(null, null)
            }
            m.setBodyBox({width:null, height:null})
        } else {
            if (p === undefined || p === null) {
                o = true;
                if (!b.animCollapse || (!k && !e)) {
                    m.setTargetSize(a, null)
                }
                m.setBodyBox({width:a, height:null})
            } else {
                n = true;
                if (!b.animCollapse || (!k && !e)) {
                    m.setTargetSize(null, p)
                }
                m.setBodyBox({width:null, height:p})
            }
        }
        if (!f && i && i.isLayout) {
            i.layout()
        }
        m.dockItems(n, o);
        if (f) {
            if (h) {
                if (h.dock == "top" || h.dock == "bottom") {
                    c.size.height = h.getHeight()
                } else {
                    c.size.width = h.getWidths()
                }
            } else {
                c.size.height = 0
            }
        }
        if (k || e) {
            if (b.animCollapse) {
                Ext.createDelegate(b.animCollapseFn, b, [c.size.width, c.size.height])()
            } else {
                Ext.createDelegate(b["after" + (k ? "Expand" : "Collapse")], b)();
                m.setTargetSize(c.size.width, c.size.height)
            }
        } else {
            m.setTargetSize(c.size.width, c.size.height)
        }
    } else {
        if (k || e) {
            if (b.animCollapse) {
                Ext.createDelegate(b.animCollapseFn, b, [a, p])()
            } else {
                Ext.createDelegate(b["after" + (k ? "Expand" : "Collapse")], b)();
                m.setTargetSize(a, p)
            }
        } else {
            m.setTargetSize(a, p);
            m.dockItems()
        }
    }
    Ext.layout.DockLayout.superclass.onLayout.call(m, a, p)
}, afterLayout:function () {
    Ext.layout.DockLayout.superclass.afterLayout.call(this)
}, dockItems:function (h, a) {
    this.calculateDockBoxes(h, a);
    var f = this.info, g = this.owner.collapsed, c = f.boxes, e = c.length, d, b;
    for (b = 0; b < e; b++) {
        d = c[b];
        if (g === true && !d.isHeader) {
            continue
        }
        d.item.setPosition(d.x, d.y)
    }
    if (h) {
        f.bodyBox.width = null
    }
    if (a) {
        f.bodyBox.height = null
    }
    this.setBodyBox(f.bodyBox)
}, calculateDockBoxes:function (m, p) {
    var x = this, y = x.getTarget(), l = x.getLayoutItems(), a = x.owner, b = a.contracted, o = a.expanded, f = a.body, t = x.info, k = t.size, c = l.length, g = t.padding, n = t.border, u, q, d, e, s, v, j;
    if (p) {
        k.height = f.getHeight() + g.top + n.top + g.bottom + n.bottom
    } else {
        k.height = y.getHeight() - y.getMargin("tb")
    }
    if (m) {
        k.width = f.getWidth() + g.left + n.left + g.right + n.right
    } else {
        k.width = y.getWidth() - y.getMargin("lr")
    }
    t.bodyBox = {x:n.left + g.left, y:n.top + g.top, width:k.width - g.left - n.left - g.right - n.right, height:k.height - n.top - g.top - n.bottom - g.bottom};
    for (q = 0; q < c; q++) {
        u = l[q];
        if (u.isHeader) {
            x.headerItem = u
        }
        d = x.initBox(u);
        if (p === true) {
            d = x.adjustAutoBox(d, q)
        } else {
            d = x.adjustSizedBox(d, q)
        }
        t.boxes.push(d)
    }
}, adjustSizedBox:function (c, b) {
    var a = this.info.bodyBox;
    switch (c.type) {
        case"top":
            c.y = a.y;
            break;
        case"left":
            c.x = a.x;
            break;
        case"bottom":
            c.y = (a.y + a.height) - c.height;
            break;
        case"right":
            c.x = (a.x + a.width) - c.width;
            break
    }
    if (!c.overlay) {
        switch (c.type) {
            case"top":
                a.y += c.height;
                a.height -= c.height;
                break;
            case"left":
                a.x += c.width;
                a.width -= c.width;
                break;
            case"bottom":
                a.height -= c.height;
                break;
            case"right":
                a.width -= c.width;
                break
        }
    }
    return c
}, adjustAutoBox:function (c, f) {
    var a = this.info, g = a.bodyBox, j = a.size, d = a.boxes, h = c.type, b, e;
    if (h == "top" || h == "bottom") {
        for (b = 0; b < f; b++) {
            e = d[b];
            if (e.stretched && e.type == "left" || e.type == "right") {
                e.height += c.height
            } else {
                if (e.type == "bottom") {
                    e.y += c.height
                }
            }
        }
    }
    switch (h) {
        case"top":
            c.y = g.y;
            if (!c.overlay) {
                g.y += c.height
            }
            j.height += c.height;
            break;
        case"bottom":
            c.y = (g.y + g.height);
            j.height += c.height;
            break;
        case"left":
            c.x = g.x;
            if (!c.overlay) {
                g.x += c.width;
                g.width -= c.width
            }
            break;
        case"right":
            if (!c.overlay) {
                g.width -= c.width
            }
            c.x = (g.x + g.width);
            break
    }
    return c
}, initBox:function (d) {
    var b = this.info.bodyBox, a = (d.dock == "top" || d.dock == "bottom"), c = {item:d, overlay:d.overlay, type:d.dock};
    if (d.stretch !== false) {
        c.stretched = true;
        if (a) {
            c.x = b.x;
            c.width = b.width;
            d.doComponentLayout(c.width - d.el.getMargin("lr"))
        } else {
            c.y = b.y;
            c.height = b.height;
            d.doComponentLayout(undefined, c.height - d.el.getMargin("tb"))
        }
    } else {
        d.doComponentLayout();
        c.width = d.getWidth();
        c.height = d.getHeight();
        if (a) {
            c.x = (d.align == "right") ? b.width - c.width : b.x
        }
    }
    if (c.width == undefined) {
        c.width = d.getWidth() + d.el.getMargin("lr")
    }
    if (c.height == undefined) {
        c.height = d.getHeight() + d.el.getMargin("tb")
    }
    return c
}, getLayoutItems:function () {
    return this.owner.getDockedItems()
}, setBodyBox:function (f) {
    var i = this, a = i.owner, g = a.body, e = a.contracted, h = a.expanded, b = i.info, d = b.bodyMargin, j = b.padding, c = b.border;
    if (Ext.isNumber(f.width)) {
        f.width -= d.left + d.right
    }
    if (Ext.isNumber(f.height)) {
        f.height -= d.top + d.bottom
    }
    i.setElementSize(g, f.width, f.height);
    g.setLeft(f.x - j.left - c.left);
    g.setTop(f.y - j.top - c.top)
}, configureItem:function (b, c) {
    Ext.layout.DockLayout.superclass.configureItem.call(this, b, c);
    var a = b.el || Ext.get(b);
    if (this.itemCls) {
        a.addCls(this.itemCls + "-" + b.dock)
    }
}, afterRemove:function (a) {
    Ext.layout.DockLayout.superclass.afterRemove.call(this, a);
    if (this.itemCls) {
        a.el.removeCls(this.itemCls + "-" + a.dock)
    }
    var b = a.el.dom;
    if (b) {
        b.parentNode.removeChild(b)
    }
    this.childrenChanged = true
}});
Ext.regLayout("dock", Ext.layout.DockLayout);
Ext.layout.FieldLayout = Ext.extend(Ext.layout.ComponentLayout, {type:"field", onLayout:function (b, a) {
    Ext.layout.FieldLayout.superclass.onLayout.call(this, owner, target);
    this.setTargetSize(b, a)
}, handleLabel:function () {
    this.owner.labelEl.setWidth(this.owner.labelWidth)
}});
Ext.regLayout("field", Ext.layout.FieldLayout);
Ext.layout.ContainerLayout = Ext.extend(Ext.layout.Layout, {type:"container", getLayoutItems:function () {
    return this.owner && this.owner.items && this.owner.items.items || []
}, afterLayout:function () {
    this.owner.afterLayout(this)
}, getTarget:function () {
    return this.owner.getTargetEl()
}});
Ext.layout.AutoContainerLayout = Ext.extend(Ext.layout.ContainerLayout, {type:"autocontainer", onLayout:function (a, e) {
    var b = this.getLayoutItems(), d = b.length, c;
    for (c = 0; c < d; c++) {
        b[c].doComponentLayout()
    }
}});
Ext.regLayout("auto", Ext.layout.AutoContainerLayout);
Ext.regLayout("autocontainer", Ext.layout.AutoContainerLayout);
Ext.layout.FitLayout = Ext.extend(Ext.layout.ContainerLayout, {itemCls:"x-fit-item", targetCls:"x-layout-fit", type:"fit", onLayout:function () {
    Ext.layout.FitLayout.superclass.onLayout.call(this);
    if (this.owner.items.length) {
        var b = this.getTargetBox(), a = this.owner.items.get(0);
        this.setItemBox(a, b);
        a.cancelAutoSize = true
    }
}, getTargetBox:function () {
    var d = this.getTarget(), b = d.getSize(), c = {left:d.getPadding("l"), right:d.getPadding("r"), top:d.getPadding("t"), bottom:d.getPadding("b")}, a = {left:d.getBorderWidth("l"), right:d.getBorderWidth("r"), top:d.getBorderWidth("t"), bottom:d.getBorderWidth("b")};
    return{width:b.width - c.left - c.right - a.left - a.right, height:b.height - c.top - c.bottom - a.top - a.bottom, x:c.left + a.left, y:c.top + a.top}
}, setItemBox:function (b, a) {
    if (b && a.height > 0) {
        a = Ext.apply({}, a);
        a.width -= b.el.getMargin("lr");
        a.height -= b.el.getMargin("tb");
        b.setCalculatedSize(a);
        b.setPosition(a)
    }
}});
Ext.regLayout("fit", Ext.layout.FitLayout);
Ext.layout.CardLayout = Ext.extend(Ext.layout.FitLayout, {type:"card", sizeAllCards:false, hideInactive:true, beforeLayout:function () {
    this.activeItem = this.getActiveItem();
    return Ext.layout.CardLayout.superclass.beforeLayout.apply(this, arguments)
}, onLayout:function () {
    Ext.layout.FitLayout.superclass.onLayout.apply(this, arguments);
    var f = this.activeItem, b = this.getLayoutItems(), e = b.length, a = this.getTargetBox(), c, d;
    for (c = 0; c < e; c++) {
        d = b[c];
        this.setItemBox(d, a)
    }
    if (!this.firstActivated && f) {
        if (f.fireEvent("beforeactivate", f) !== false) {
            f.fireEvent("activate", f)
        }
        this.firstActivated = true
    }
}, getActiveItem:function () {
    if (!this.activeItem && this.owner) {
        this.activeItem = this.parseActiveItem(this.owner.activeItem)
    }
    if (this.activeItem && this.owner.items.items.indexOf(this.activeItem) != -1) {
        return this.activeItem
    }
    return null
}, parseActiveItem:function (a) {
    if (a && a.isComponent) {
        return a
    } else {
        if (typeof a == "number" || a == undefined) {
            return this.getLayoutItems()[a || 0]
        } else {
            return this.owner.getComponent(a)
        }
    }
}, configureItem:function (b, a) {
    Ext.layout.FitLayout.superclass.configureItem.call(this, b, a);
    if (this.hideInactive && this.activeItem !== b) {
        b.hide()
    } else {
        b.show()
    }
}, onRemove:function (a) {
    if (a === this.activeItem) {
        this.activeItem = null;
        if (this.owner.items.getCount() == 0) {
            this.firstActivated = false
        }
    }
}, getAnimation:function (b, a) {
    var c = (b || {}).cardSwitchAnimation;
    if (c === false) {
        return false
    }
    return c || a.cardSwitchAnimation
}, setActiveItem:function (b, f) {
    var e = this, a = e.owner, g = Ext.getDoc(), d = e.activeItem, c;
    f = (f == undefined) ? this.getAnimation(b, a) : f;
    b = e.parseActiveItem(b);
    c = a.items.indexOf(b);
    if (c == -1) {
        a.add(b)
    }
    if (b && d != b && a.onBeforeCardSwitch(b, d, c, !!f) !== false) {
        if (!b.rendered) {
            this.layout()
        }
        if (b.fireEvent("beforeactivate", b, d) === false) {
            return false
        }
        if (d && d.fireEvent("beforedeactivate", d, b) === false) {
            return false
        }
        if (b.hidden) {
            b.show()
        }
        e.activeItem = b;
        if (f) {
            g.on("click", Ext.emptyFn, e, {single:true, preventDefault:true});
            Ext.Anim.run(b, f, {out:false, autoClear:true, scope:e, after:function () {
                Ext.defer(function () {
                    g.un("click", Ext.emptyFn, e)
                }, 50, e);
                b.fireEvent("activate", b, d);
                if (!d) {
                    a.onCardSwitch(b, d, c, true)
                }
            }});
            if (d) {
                Ext.Anim.run(d, f, {out:true, autoClear:true, after:function () {
                    d.fireEvent("deactivate", d, b);
                    if (e.hideInactive && e.activeItem != d) {
                        d.hide()
                    }
                    a.onCardSwitch(b, d, c, true)
                }})
            }
        } else {
            b.fireEvent("activate", b, d);
            if (d) {
                d.fireEvent("deactivate", d, b);
                if (e.hideInactive) {
                    d.hide()
                }
            }
            a.onCardSwitch(b, d, c, false)
        }
        return b
    }
    return false
}, getNext:function (c) {
    var a = this.getLayoutItems(), b = a.indexOf(this.activeItem);
    return a[b + 1] || (c ? a[0] : false)
}, next:function (b, a) {
    return this.setActiveItem(this.getNext(a), b)
}, getPrev:function (c) {
    var a = this.getLayoutItems(), b = a.indexOf(this.activeItem);
    return a[b - 1] || (c ? a[a.length - 1] : false)
}, prev:function (b, a) {
    return this.setActiveItem(this.getPrev(a), b)
}});
Ext.regLayout("card", Ext.layout.CardLayout);
Ext.layout.BoxLayout = Ext.extend(Ext.layout.ContainerLayout, {type:"box", targetCls:"x-layout-box", innerCls:"x-layout-box-inner", pack:"start", align:"center", notifyOwnerCtContainer:true, fixedLayout:false, direction:"normal", onLayout:function () {
    Ext.layout.BoxLayout.superclass.onLayout.call(this);
    if (this.pack === "left" || this.pack === "top") {
        this.pack = "start"
    } else {
        if (this.pack === "right" || this.pack === "bottom") {
            this.pack = "end"
        }
    }
    var d = this.getTarget(), c = d.parent(), b = (c.getWidth() - c.getPadding("lr") - c.getBorderWidth("lr")) + "px", a = (c.getHeight() - c.getPadding("tb") - c.getBorderWidth("tb")) + "px";
    d.setStyle({"-webkit-box-orient":this.orientation, "-webkit-box-direction":this.direction, "-webkit-box-pack":this.pack, "-webkit-box-align":this.align});
    if (this.orientation == "horizontal") {
        d.setStyle({"min-width":b, height:a})
    } else {
        d.setStyle({"min-height":a, width:b})
    }
    this.prepareFlexedItems();
    this.setFlexedItems()
}, prepareFlexedItems:function () {
    var a = this.getLayoutItems(), d = a.length, c, b;
    for (b = 0; b < d; b++) {
        c = a[b];
        if (c.flex != undefined) {
            c.el.setStyle("position", "absolute");
            c.boxEl = this.createBoxEl(c)
        } else {
            c.doComponentLayout()
        }
    }
}, setFlexedItems:function () {
    var a = this.getLayoutItems(), d = a.length, c, b;
    for (b = 0; b < d; b++) {
        c = a[b];
        if (c.flex != undefined) {
            c.boxSize = c.boxEl.getSize()
        }
    }
    for (b = 0; b < d; b++) {
        c = a[b];
        if (c.flex != undefined) {
            c.el.setStyle("position", "");
            if (this.align == "stretch") {
                c.setSize(c.boxSize)
            } else {
                if (this.orientation == "horizontal") {
                    c.setWidth(c.boxSize.width)
                } else {
                    c.setHeight(c.boxSize.height)
                }
            }
            c.boxEl.remove();
            delete c.boxEl;
            delete c.boxSize
        }
    }
}, getTarget:function () {
    var a = this.owner, b = this.innerCt;
    if (!b) {
        if (a.scrollEl) {
            b = a.scrollEl.addCls(this.innerCls)
        } else {
            b = a.getTargetEl().createChild({cls:this.innerCls})
        }
        this.innerCt = b
    }
    return b
}, createBoxEl:function (b) {
    var a = b.el;
    return a.insertSibling({style:"margin-top: " + a.getMargin("tb") + "px; margin-left: " + a.getMargin("lr") + "px; -webkit-box-flex: " + b.flex})
}});
Ext.layout.HBoxLayout = Ext.extend(Ext.layout.BoxLayout, {orientation:"horizontal"});
Ext.regLayout("hbox", Ext.layout.HBoxLayout);
Ext.layout.VBoxLayout = Ext.extend(Ext.layout.BoxLayout, {orientation:"vertical"});
Ext.regLayout("vbox", Ext.layout.VBoxLayout);
Ext.plugins.ListPagingPlugin = Ext.extend(Ext.util.Observable, {autoPaging:false, loadMoreText:"Load More...", init:function (a) {
    this.list = a;
    a.onBeforeLoad = Ext.util.Functions.createInterceptor(a.onBeforeLoad, this.onBeforeLoad, this);
    this.mon(a, "update", this.onListUpdate, this)
}, onListUpdate:function () {
    if (!this.rendered) {
        this.render()
    }
    this.el.appendTo(this.list.getTargetEl());
    if (!this.autoPaging) {
        this.el.removeCls("x-loading")
    }
    this.loading = false
}, render:function () {
    var b = this.list, c = b.getTargetEl(), a = "";
    if (!this.autoPaging) {
        a += '<div class="x-list-paging-msg">' + this.loadMoreText + "</div>"
    }
    this.el = c.createChild({cls:"x-list-paging" + (this.autoPaging ? " x-loading" : ""), html:a + Ext.LoadingSpinner});
    if (this.autoPaging) {
        this.mon(c.getScrollParent(), "scrollend", this.onScrollEnd, this)
    } else {
        this.mon(this.el, "tap", this.onPagingTap, this)
    }
    this.rendered = true
}, onBeforeLoad:function () {
    if (this.loading && this.list.store.getCount() > 0) {
        this.list.loadMask.disable();
        return false
    }
}, onPagingTap:function (a) {
    if (!this.loading) {
        this.loading = true;
        this.list.store.nextPage();
        this.el.addCls("x-loading")
    }
}, onScrollEnd:function (a, b) {
    if (b.y >= Math.abs(a.offsetBoundary.top)) {
        this.loading = true;
        this.list.store.nextPage()
    }
}});
Ext.preg("listpaging", Ext.plugins.ListPagingPlugin);
Ext.plugins.PullRefreshPlugin = Ext.extend(Ext.util.Observable, {pullRefreshText:"Pull down to refresh...", releaseRefreshText:"Release to refresh...", loadingText:"Loading...", snappingAnimationDuration:150, refreshFn:null, pullTpl:new Ext.XTemplate('<div class="x-list-pullrefresh">', '<div class="x-list-pullrefresh-arrow"></div>', Ext.LoadingSpinner, '<div class="x-list-pullrefresh-wrap">', '<h3 class="x-list-pullrefresh-message">{message}</h3>', '<div class="x-list-pullrefresh-updated">Last Updated: <span>{lastUpdated:date("m/d/Y h:iA")}</span></div>', "</div>", "</div>"), isRefreshing:false, isLoading:false, currentViewState:"", init:function (a) {
    this.list = a;
    this.lastUpdated = new Date();
    a.on("update", this.onListUpdate, this);
    a.onBeforeLoad = Ext.util.Functions.createInterceptor(a.onBeforeLoad, this.onBeforeLoad, this)
}, onListUpdate:function () {
    if (!this.rendered) {
        this.render()
    }
    this.list.getTargetEl().insertFirst(this.el);
    if (!this.refreshFn) {
        this.onLoadComplete.call(this)
    }
}, render:function () {
    var b = this.list, c = b.getTargetEl(), a = c.getScrollParent();
    if (!this.pullTpl.isTemplate) {
        this.pullTpl = new Ext.XTemplate(this.pullTpl)
    }
    this.el = this.pullTpl.insertFirst(c, {message:this.pullRefreshText, lastUpdated:this.lastUpdated}, true);
    this.messageEl = this.el.down(".x-list-pullrefresh-message");
    this.updatedEl = this.el.down(".x-list-pullrefresh-updated > span");
    this.pullHeight = this.el.getHeight();
    this.scroller = a;
    a.on("bouncestart", this.onBounceStart, this);
    a.on("offsetchange", this.onOffsetChange, this);
    a.on("bounceend", this.onBounceEnd, this);
    a.on("offsetboundaryupdate", this.onOffsetBoundaryUpdate, this);
    this.rendered = true
}, onOffsetBoundaryUpdate:function (a, b) {
    if (this.isRefreshing) {
        b.bottom += this.pullHeight
    }
}, onBounceStart:function (a, b) {
    if (b.axis === "y") {
        if (!this.isRefreshing && a.offset.y > this.pullHeight) {
            this.isRefreshing = true;
            this.onOffsetBoundaryUpdate(a, a.offsetBoundary)
        }
    }
}, onBounceEnd:function (a, b) {
    if (b.axis === "y") {
        if (this.isRefreshing) {
            this.isRefreshing = false;
            this.setViewState("loading");
            this.isLoading = true;
            if (this.refreshFn) {
                this.refreshFn.call(this, this.onLoadComplete, this)
            } else {
                this.list.getStore().load()
            }
        }
    }
}, onOffsetChange:function (a, b) {
    if (b.y > 0 && !this.isRefreshing && !this.isLoading) {
        if (b.y > this.pullHeight) {
            this.setViewState("release")
        } else {
            this.setViewState("pull")
        }
    }
}, setViewState:function (a) {
    if (a === this.currentViewState) {
        return this
    }
    this.currentViewState = a;
    switch (a) {
        case"pull":
            this.messageEl.setHTML(this.pullRefreshText);
            this.el.removeCls(["x-list-pullrefresh-release", "x-list-pullrefresh-loading"]);
            break;
        case"release":
            this.messageEl.setHTML(this.releaseRefreshText);
            this.el.addCls("x-list-pullrefresh-release");
            break;
        case"loading":
            this.messageEl.setHTML(this.loadingText);
            this.el.addCls("x-list-pullrefresh-loading");
            break
    }
    return this
}, onBeforeLoad:function () {
    if (this.isLoading && this.list.store.getCount() > 0) {
        this.list.loadMask.disable();
        return false
    }
}, onLoadComplete:function () {
    var a = this;
    if (this.isLoading) {
        this.isLoading = false;
        this.lastUpdated = new Date();
        this.setViewState("pull");
        this.updatedEl.setHTML(Ext.util.Format.date(this.lastUpdated, "m/d/Y h:iA"));
        setTimeout(function () {
            a.scroller.updateBoundary(a.snappingAnimationDuration)
        }, 100)
    }
}});
Ext.preg("pullrefresh", Ext.plugins.PullRefreshPlugin);